PndFastSim Class Reference

#include <PndFastSim.h>

Inheritance diagram for PndFastSim:

Public Member Functions
	PndFastSim (bool persist=true)
	~PndFastSim ()
void	Register ()
virtual InitStatus	Init ()
virtual void	Finish ()
virtual void	Exec (Option_t *opt)
bool	AddDetector (std::string name, std::string params="")
bool	AddDetector (PndFsmAbsDet *det)
void	SetVerbosity (int vb)
bool	EnableSplitoffs (std::string fname="splitpars.dat")
bool	MergeNeutralClusters (bool merge=true, double par=0.389)
void	EnableElectronBremsstrahlung (bool brems=true)
void	EnablePropagation (bool propagate=true, bool tostartvtx=true, bool usecovmatrix=true, double tolerance=0.0)
void	SetUseFlatCov (bool v=true)
void	SetMultFilter (TString type, int min, int max=1000)
void	SetInvMassFilter (TString filter, double min, double max, int mult=1)
void	SetSeed (unsigned int seed=65539)

Private Member Functions
PndFsmResponse *	sumResponse (FsmResponseList respList)
int	acceptFilters (RhoCandList &l)
int	chCon (int i)
void	copyAndSetMass (RhoCandList &l, RhoCandList &nl, int pdg)
bool	cutAndSmear (PndFsmTrack *t, PndFsmResponse *r)
bool	cutAndSmear (PndFsmTrack *t)
void	smearEnergy (PndFsmTrack *t, double dE)
void	smearMomentum (PndFsmTrack *t, double dp)
void	smearTheta (PndFsmTrack *t, double dtheta)
void	smearPhi (PndFsmTrack *t, double dphi)
void	smearVertex (PndFsmTrack *t, TVector3 dV)
void	smearM (PndFsmTrack *t, double dm)
void	smearM2 (PndFsmTrack *t, double m2)
void	smearMvddEdx (PndFsmTrack *t, double dedx)
void	smearTpcdEdx (PndFsmTrack *t, double dedx)
void	smearSttdEdx (PndFsmTrack *t, double dedx)
void	SetFlatCovMatrix (PndFsmTrack *t, double dp=0., double dtheta=0., double dphi=0., double dE=0., double dx=0., double dy=0., double dz=0.)
void	UpdateGammaHit (PndFsmTrack *t)
virtual void	SetParContainers ()
bool	smearTrack (PndFsmTrack *t, int idx=-1)
	ClassDef (PndFastSim, 1)

Private Attributes
TClonesArray *	fMcCandidates
TClonesArray *	fPidChargedCand
TClonesArray *	fPidNeutralCand
TClonesArray *	fMicroCandidates
TClonesArray *	fPidChargedProb
TClonesArray *	fPidNeutralProb
	PndPidProbability TCA for charged particles. More...
std::map< TString, TClonesArray * >	fPidArrayList
	PndPidProbability TCA for neutral particles. More...
TClonesArray *	fEventInfo
	PndPidProbability TCA's for individual detectors. More...
TRandom3 *	fRand
int	fVb
int	evtcnt
TF1 *	fspo [5][4]
TF1 *	fBremsEnergy
bool	fGenSplitOffs
bool	fMergeNeutralClusters
bool	fElectronBrems
double	fMergeProbPar
bool	fPropagate
bool	fToStartVtx
bool	fUseCovMatrix
bool	fUseFlatCovMatrix
double	fTolerance
bool	fApplyFilter
int	fMultMin [6]
int	fMultMax [6]
TString	fInvMassFilter
double	fInvMassMin
double	fInvMassMax
int	fInvMassMult
int	fCombIndex [5]
int	fCombMult
bool	fChargeConj
int	fNAccept
bool	fPersist
PndFsmDetFactory *	fDetFac
std::string	fAddedDets
FsmAbsDetList	fDetList
TDatabasePDG *	fdbPdg

Static Private Attributes
static TMatrixD	fRho
static TMatrixD	fEta

Detailed Description

Definition at line 32 of file PndFastSim.h.

Constructor & Destructor Documentation

PndFastSim::PndFastSim

(

bool

persist = true

)

Default constructor

Definition at line 62 of file PndFastSim.cxx.

References AddDetector(), fAddedDets, fApplyFilter, fChargeConj, fCombIndex, fCombMult, fdbPdg, fDetFac, fElectronBrems, fGenSplitOffs, fInvMassFilter, fInvMassMax, fInvMassMin, fInvMassMult, fMergeNeutralClusters, fMergeProbPar, fMultMax, fMultMin, fNAccept, fPersist, fPropagate, fRand, fToStartVtx, fUseCovMatrix, fUseFlatCovMatrix, fVb, i, and PndFsmRandom::Instance().

                                   :
FairTask("Panda Fast Simulation") {
  //  fCandidates = new TClonesArray("TParticle");
  fRand=PndFsmRandom::Instance();
  fDetFac = new PndFsmDetFactory;
  fAddedDets=" ";
  fVb=0;
  fGenSplitOffs=false;
  fMergeNeutralClusters=false;
  fMergeProbPar = 0.389;
  fElectronBrems = false;
  fUseFlatCovMatrix=true;
  fPropagate=false;
  fToStartVtx=false;
  fUseCovMatrix=false;
  fdbPdg = TDatabasePDG::Instance();
  AddDetector("IdealPid");
    
  fInvMassFilter="";
  fInvMassMin=0.;
  fInvMassMax=1000.;
  fInvMassMult=0;
  fChargeConj=false;
  fCombMult=0;
  for (int i=0;i<5;++i) fCombIndex[i]=0;
  for (int i=0;i<6;++i) {fMultMin[i]=0; fMultMax[i]=1000;}
  
  
  fApplyFilter=false;
  fNAccept = 0;

  fPersist = persist;
}

PndFastSim::~PndFastSim

(

)

Destructor

Definition at line 98 of file PndFastSim.cxx.

References fDetFac, fEventInfo, fMcCandidates, fPidChargedCand, fPidChargedProb, fPidNeutralCand, fPidNeutralProb, and fRand.

                        {
  FairRootManager *fManager =FairRootManager::Instance();
  fManager->Write();

  //if (fChargedCandidates) {fChargedCandidates->Delete(); delete fChargedCandidates;}
  //if (fNeutralCandidates) {fNeutralCandidates->Delete(); delete fNeutralCandidates;}
  if (fMcCandidates) {fMcCandidates->Delete(); delete fMcCandidates;}
  //if (fMicroCandidates) {fMicroCandidates->Delete(); delete fMicroCandidates;}
  if (fPidChargedCand) {fPidChargedCand->Delete(); delete fPidChargedCand;}
  if (fPidNeutralCand) {fPidNeutralCand->Delete(); delete fPidNeutralCand;}

  if (fPidChargedProb) {fPidChargedProb->Delete(); delete fPidChargedProb;}
  if (fPidNeutralProb) {fPidNeutralProb->Delete(); delete fPidNeutralProb;}

  if (fEventInfo) {fEventInfo->Delete(); delete fEventInfo;}

  if (fDetFac) delete fDetFac;
  if (fRand) delete fRand;
}

Member Function Documentation

int PndFastSim::acceptFilters ( RhoCandList &  l )

private

Definition at line 429 of file PndFastSim.cxx.

References RhoCandList::Add(), chCon(), RhoCandList::Combine(), RhoCandList::CombineAndAppend(), copyAndSetMass(), d, fabs(), fChargeConj, fCombIndex, fCombMult, fInvMassMax, fInvMassMin, fInvMassMult, fMultMax, fMultMin, fVb, RhoCandList::GetLength(), i, idx, and RhoCandList::Select().

Referenced by Exec().

{
  RhoCandList plus, minus,lsp[14],comb, combsel;
  
  int i,j, nplus, nminus, ngam;
  
  for (i=0;i<l.GetLength();++i)
  {
    if (l[i]->Charge()>0) plus.Add(l[i]);
    else if (l[i]->Charge()<0) minus.Add(l[i]);
    else if (fabs(l[i]->Charge())<1e-6) lsp[10].Add(l[i]);
  }
  
  // apply multiplicity filters

  // positiv particles
  nplus = plus.GetLength();
  if (nplus<fMultMin[0] || nplus>fMultMax[0]) return 1;
  
  // negative particles
  nminus = minus.GetLength();
  if (nminus<fMultMin[1] || nminus>fMultMax[1]) return 2;
  
  // neutrals
  ngam = lsp[10].GetLength();
  if (ngam<fMultMin[2] || ngam>fMultMax[2]) return 3;

  int pdgcodes[10] = {-11, 11, -13, 13, 211, -211, 321, -321, 2212, -2212};
  
  RhoMassParticleSelector msel("msel",(fInvMassMax+fInvMassMin)/2,(fInvMassMax-fInvMassMin));
  RhoMassParticleSelector pi0sel("pi0sel",0.135,0.06);
  RhoMassParticleSelector kssel("kssel",0.4976,0.08);
  RhoMassParticleSelector etasel("msel",0.547,0.08);

  // pi0s
  if (fMultMin[3]>0 || fMultMax[3]<1000) 
  {
    lsp[11].Combine(lsp[10],lsp[10]);
    lsp[11].Select(&pi0sel);
    
    int npi0=lsp[11].GetLength();
    if (npi0<fMultMin[3] || npi0>fMultMax[3]) return 4;
  }
  
  // ks
  if (fMultMin[4]>0 || fMultMax[4]<1000) 
  {
  
    copyAndSetMass(plus,  lsp[4], pdgcodes[4]);
    copyAndSetMass(minus, lsp[5], pdgcodes[5]);
        
    lsp[12].Combine(lsp[4],lsp[5]);
    lsp[12].Select(&kssel);
    
    int nks=lsp[12].GetLength();
    if (nks<fMultMin[4] || nks>fMultMax[4]) return 5;
  }
  
  // etas
  if (fMultMin[5]>0 || fMultMax[5]<1000) 
  {
    lsp[13].Combine(lsp[10],lsp[10]);
    lsp[13].Select(&etasel);
    
    int neta=lsp[13].GetLength();
    if (neta<fMultMin[5] || neta>fMultMax[5]) return 6;
  }
  
  // apply inv mass filter
  // list indices: 0:e+ 1:e-, 2:mu+, ... 9:p-, 10:gamma, 11:pi0(gg), 12:KS, 13:eta(gg)
  if (fInvMassMult>0)
  {
    if (fVb>0) cout <<"Comb mult = "<<fCombMult<<endl;
    for (i=0;i<fCombMult;++i)
    {
      // prepare all needed lists
      int idx = fCombIndex[i];
      int ccidx = chCon(idx);
      
      if (fVb) cout <<"IDX:"<<idx<<"  CCIDX:"<<ccidx<<endl;
      
      // charged particle species
      if (idx<10 && lsp[idx].GetLength()==0)
      {
        if (idx%2) copyAndSetMass(minus,  lsp[idx], pdgcodes[idx]);
        else copyAndSetMass(plus,  lsp[idx], pdgcodes[idx]);
      } 
      
      // if charged conjugation needed, prepare those lists
      if (fChargeConj && ccidx<10 && lsp[ccidx].GetLength()==0)
      {
        if (ccidx%2) copyAndSetMass(minus,  lsp[ccidx], pdgcodes[ccidx]);
        else copyAndSetMass(plus,  lsp[ccidx], pdgcodes[ccidx]);
      } 
      
      // pi0s
      if (idx==11 && lsp[idx].GetLength()==0) 
      {
        lsp[11].Combine(lsp[10],lsp[10]);
        lsp[11].Select(&pi0sel);
      }
      
      // ks
      if (idx==12 && lsp[idx].GetLength()==0) 
      {
        if (lsp[4].GetLength()==0) copyAndSetMass(plus,  lsp[4], pdgcodes[4]);
        if (lsp[5].GetLength()==0) copyAndSetMass(minus, lsp[5], pdgcodes[5]);
        
        lsp[12].Combine(lsp[4],lsp[5]);
        lsp[12].Select(&kssel);
      }
      
      // eta
      if (idx==13 && lsp[idx].GetLength()==0) 
      {
        lsp[13].Combine(lsp[10],lsp[10]);
        lsp[13].Select(&etasel);
      }
    }
    
    int *iar=fCombIndex;
    
    switch (fCombMult)
    {
    case 2: comb.Combine(lsp[iar[0]], lsp[iar[1]]);
      if (fChargeConj) 
          comb.CombineAndAppend(lsp[chCon(iar[0])], lsp[chCon(iar[1])]);
      break;
    case 3: comb.Combine(lsp[iar[0]], lsp[iar[1]], lsp[iar[2]]);
      if (fChargeConj) 
          comb.CombineAndAppend(lsp[chCon(iar[0])], lsp[chCon(iar[1])], lsp[chCon(iar[2])]);
      break;
    case 4: comb.Combine(lsp[iar[0]], lsp[iar[1]], lsp[iar[2]], lsp[iar[3]]);
      if (fChargeConj) 
          comb.CombineAndAppend(lsp[chCon(iar[0])], lsp[chCon(iar[1])], lsp[chCon(iar[2])], lsp[chCon(iar[3])]);
      break;
    case 5: comb.Combine(lsp[iar[0]], lsp[iar[1]], lsp[iar[2]], lsp[iar[3]], lsp[iar[4]]);
      if (fChargeConj) 
          comb.CombineAndAppend(lsp[chCon(iar[0])], lsp[chCon(iar[1])], lsp[chCon(iar[2])],
                  lsp[chCon(iar[3])], lsp[chCon(iar[4])]);
      break;
    }
    
    combsel.Select(comb,&msel);
    if (combsel.GetLength()<fInvMassMult) 
    {
      if (fVb>0) 
      {
        cout<<"filter list masses: ";
        for (i=0;i<comb.GetLength();++i) 
        {
          std::cout <<comb[i]->M()<<" ("<<comb[i]->GetMarker(0)<<")  "<<endl;
          cout <<" ("<<comb[i]->P4().X()<<","<<comb[i]->P4().Y()<<","<<comb[i]->P4().Z()<<","<<comb[i]->P4().E()<<")"<<endl;
          for (j=0;j<comb[i]->NDaughters();++j)
          {
            RhoCandidate *d=comb[i]->Daughter(j);
            cout<<*d<<endl;
          }
        }
        cout<<endl;
      }
      return 7;
    }
    
  }
  
  return 0;
}

bool PndFastSim::AddDetector	(	std::string	name,
		std::string	params = ""
	)

Definition at line 313 of file PndFastSim.cxx.

References PndFsmDetFactory::create(), fAddedDets, fDetFac, fDetList, and fVb.

Referenced by PndFastSim(), prod_fsim(), QAmacro_fastsim_1(), quickfsimana(), run_fast(), simfast(), simfast_cmp(), simfast_dpm(), simfast_dpm_cmp(), simfast_opt(), simfast_single_allpid(), simfast_singletracks(), and tut_fastsim().

{
  if (name =="")
  {
    cout <<" -W-  (PndFastSim::AddDetector) - No name given, no detector added!"<<endl;

  }

  if (fAddedDets.find(" "+name+" ")!=std::string::npos)
  {
    std::cout <<" -W-  (PndFastSim::AddDetector) - Detector <"<<name<<"> already appended - skipping!"<<std::endl;
    return false;
  }
  fAddedDets.append(std::string(name+" "));

  PndFsmAbsDet *det=0;
  det=fDetFac->create(name,params);
  if (!det) return false;

  fDetList.push_back(det);
  if (fVb>0)  std::cout<<" -I- (PndFastSim::AddDetector) - Added detector "<<name<<" with params <"<<params<<">"<<std::endl;
  return true;
}

bool PndFastSim::AddDetector

(

PndFsmAbsDet *

det

)

Definition at line 337 of file PndFastSim.cxx.

References PndFsmAbsDet::detName(), fAddedDets, fDetList, and fVb.

{
  if (det) {
    fDetList.push_back(det);
    fAddedDets.append(det->detName()+" ");
    if (fVb>0)  std::cout<<" -I- (PndFastSim::AddDetector) - Added detector "<<det->detName()<<std::endl;
  }
  return det;
}

int PndFastSim::chCon ( int  i )

private

Definition at line 422 of file PndFastSim.cxx.

References i.

Referenced by acceptFilters().

{
  int cc=i;
  if (i<10) i%2 ? cc=i-1 : cc=i+1;
  return cc;
}

PndFastSim::ClassDef ( PndFastSim  , 1    )

private

void PndFastSim::copyAndSetMass ( RhoCandList &  l, RhoCandList &  nl, int  pdg  )

private

Definition at line 362 of file PndFastSim.cxx.

References RhoCandList::Add(), c, RhoCandList::Cleanup(), RhoCandList::GetLength(), i, and RhoCandidate::SetType().

Referenced by acceptFilters().

{
  nl.Cleanup();
  for (int i=0;i<l.GetLength();++i)
  {
    RhoCandidate c(*(l[i]));
    c.SetType(pdg);
    nl.Add(&c);
  }
}

bool PndFastSim::cutAndSmear ( PndFsmTrack *  t, PndFsmResponse *  r  )

private

Definition at line 1039 of file PndFastSim.cxx.

References c, PndFsmTrack::charge(), dE, PndFsmResponse::dE(), PndFsmResponse::detected(), PndFsmResponse::dm(), PndFsmResponse::dp(), PndFsmResponse::dphi(), dtheta, PndFsmResponse::dtheta(), PndFsmResponse::dV(), fabs(), fEta, fPropagate, fRand, fRho, fTolerance, fToStartVtx, fUseCovMatrix, fUseFlatCovMatrix, PndFsmTrack::GetHelixCov(), PndFsmTrack::GetHelixOmega(), PndFsmTrack::GetHelixParams(), PndFsmTrack::GetHelixTanDip(), PndFsmTrack::HelixRep(), ir, PndFsmResponse::m2(), m2(), PndFsmResponse::MvddEdx(), p, p2, PndFsmTrack::p4(), PndFsmTrack::Propagate(), SetFlatCovMatrix(), sin(), smearEnergy(), smearM(), smearM2(), smearMomentum(), smearMvddEdx(), smearPhi(), smearSttdEdx(), smearTheta(), smearVertex(), sqrt(), PndFsmTrack::startVtx(), PndFsmResponse::SttdEdx(), theta, and UpdateGammaHit().

Referenced by cutAndSmear(), and smearTrack().

{
  if( !(r->detected()) ) return false;

  double charge = t->charge();
  double dE     = r->dE();
  double dp     = r->dp();
  double dtheta = r->dtheta();
  double dphi   = r->dphi();
  double dm     = r->dm();
  double m2     = r->m2();
  double MvddEdx =r->MvddEdx();
  double SttdEdx =r->SttdEdx();
  TVector3 dV   = r->dV();
  //r->print(cout);
  //this removes candidates, which only have hit a PID-only device (like Cherenkov, TOF ...)
  if (fabs(charge)>1e-6 && fabs(dp)<1e-8) return false;
  if (fabs(charge)<1e-6 && fabs(dE)<1e-8) return false;

  // now produce some correlated errors
  if (fPropagate && fabs(charge)>1e-6) {
    t->HelixRep(t->startVtx() );
    double p2 = t->p4().Vect().Mag2();
    double omega = t->GetHelixOmega();
    double tandip = t->GetHelixTanDip();
    double theta = t->p4().Theta();

    static TVectorD gaus(5);
    for (char p=0;p<5;p++) gaus[p]=fRand->Gaus();
    if (fUseCovMatrix) gaus*=fEta;
    // calculate track par errors
    double err[5];
    // d0 (guessed), phi0, z0
    err[0] = 0.5*(dV.X()+dV.Y());
    err[1] = dphi;
    err[3] = dV.Z();
    // omega needs some error propagation (momentum and theta are uncorrelated)
    err[2] = omega * sqrt( dp*dp/p2 + pow(dtheta*tandip,2) );
    // as well as tandip
    err[4] = dtheta/pow(sin(theta),2);
    // smear track pars
    for (int p=0;p<5;p++) t->GetHelixParams()[p] += err[p] * gaus[p];
    
    // write scaled cov matrix
    for (int ir=0;ir<5;ir++) {
      for (int c=0;c<5;c++) {
        t->GetHelixCov()(ir,c) = fRho(ir,c)*fabs(err[ir]*err[c])*(fUseCovMatrix||ir==c);
      }
    }
    t->Propagate( fToStartVtx ? t->startVtx() : TVector3(0,0,0), fTolerance);
    // uncharged particles remain uncorrelated
  } else {
    //first set cov, using mctruth for correct calculation of jacobian
    if (fUseFlatCovMatrix) SetFlatCovMatrix(t,dp,dtheta,dphi,dE,dV.X(),dV.Y(),dV.Z());
    if (dE != 0.0)     smearEnergy(t,dE);
    if (dp != 0.0)     smearMomentum(t,dp);
    if (dtheta != 0.0) smearTheta(t,dtheta);
    if (dphi != 0.0)   smearPhi(t,dphi);
    if ( fabs(charge)>1e-6 && (dV.X() != 0.0 || dV.Y() != 0.0 || dV.Z() != 0.0)) smearVertex(t,dV);
    if ( fabs(charge)<1e-6 ) UpdateGammaHit(t);
  }
  if (dm != 0.0)     smearM(t,dm);
  if( m2!=0.0)       smearM2(t,m2);           // mass^2 of track after tof
  if(MvddEdx!=0.0)   smearMvddEdx(t,MvddEdx); // dEdx of track after Mvd
  if(SttdEdx!=0.0)   smearSttdEdx(t,SttdEdx); // dEdx of track after Stt
  return true;
}

bool PndFastSim::cutAndSmear ( PndFsmTrack *  t )

private

Definition at line 1031 of file PndFastSim.cxx.

References cutAndSmear(), and PndFsmTrack::detResponse().

{
  return cutAndSmear(t, t->detResponse());
}

void PndFastSim::EnableElectronBremsstrahlung ( bool  brems = true )

inline

Definition at line 62 of file PndFastSim.h.

References fElectronBrems.

Referenced by prod_fsim(), quickfsimana(), simfast(), simfast_opt(), and tut_fastsim().

{fElectronBrems=brems;}

void PndFastSim::EnablePropagation	(	bool	propagate = true,
		bool	tostartvtx = true,
		bool	usecovmatrix = true,
		double	tolerance = 0.0
	)

Definition at line 303 of file PndFastSim.cxx.

References fPropagate, fTolerance, fToStartVtx, fUseCovMatrix, and propagate().

Referenced by QAmacro_fastsim_1(), run_fast(), simfast_cmp(), and simfast_dpm_cmp().

                                                                                                       {
  fPropagate=propagate;
  fToStartVtx=tostartvtx;
  fUseCovMatrix=usecovmatrix;
  fTolerance=tolerance;
}

bool PndFastSim::EnableSplitoffs

(

std::string

fname = "splitpars.dat"

)

Definition at line 224 of file PndFastSim.cxx.

References fGenSplitOffs, fspo, fVb, and i.

Referenced by prod_fsim(), quickfsimana(), simfast(), simfast_dpm(), simfast_opt(), simfast_single_allpid(), simfast_singletracks(), and tut_fastsim().

{
  if (fname=="")
  {
    cout <<" -W-  (PndFastSim::EnableSplitoffs) - no filename given; no split offs will be produced."<<endl;
    return false;
  }

  /*
  prepare the split off parametrization
  expected in the parameter file:
  - four blocks (mom, phi, tht, multiplicity) with the parametrization structured like
  * <n_i>   <lowlimit>   <uplimit>   <model-string(in ROOT TF1 format)>
  * 5 lines of parameter sets with info for pid=11,13,211,321,2212
  <pid> <p1> <p2> ... <p_n_i>

  for the moment momentum independent
    models:
    momentum     : expo(0)+expo(2) = 4 params
    tht+phi      : gaus(0)+gaus(3) = 6 params
    multiplicity : expo(0)+gaus(2) = 5 params
    */

  ifstream pars(fname.data());

  if ( (pars.rdstate() & ifstream::failbit ) != 0 )
  {
    cout << " -W-  (PndFastSim::EnableSplitoffs) -  Error opening '"<<fname<<"'; no split offs will be produced."<<endl;
    return false;
  }


  int i,j,k;
  char tmp[50];

  string model[4];
  int numpars[4];
  double rangeup[4],rangelow[4];
  double curpar;


  //loop over blocks
  for (i=0;i<4;i++)
  {
    pars>>model[i]>>numpars[i]>>rangelow[i]>>rangeup[i];
    if (fVb) cout <<" -I-  (PndFastSim::EnableSplitoffs)  split off model #"<<i<<": '"<<model[i]<<"' with "<<numpars[i]<<" params."<<endl;

    //loop over pid
    for (j=0;j<5;j++)
    {
      sprintf(tmp,"f%d%d",j,i);
      fspo[j][i]=new TF1(tmp,model[i].data());

      //loop over params
      pars>>curpar;   // read the dummy PID value
      for (k=0;k<numpars[i];k++)
      {
        pars>>curpar;
        fspo[j][i]->SetParameter(k,curpar);
      }

      fspo[j][i]->SetRange(rangelow[i],rangeup[i]);
      if (fVb) fspo[j][i]->Print();
    }
  }

  if (fVb) cout <<" -I-  (PndFastSim::EnableSplitoffs) - Successfully read "<<fname<<endl;

  pars.close();

  fGenSplitOffs=true;

  return true;
}

void PndFastSim::Exec ( Option_t *  opt )

virtual

Virtual method Exec

Definition at line 616 of file PndFastSim.cxx.

References acceptFilters(), RhoCandList::Add(), c, PndFsmTrack::charge(), PndFsmTrack::Cov7(), PndFsmTrack::detResponse(), PndFsmResponse::DrcBarrelThtc(), PndFsmResponse::DrcBarrelThtcErr(), PndFsmResponse::DrcDiscThtc(), PndFsmResponse::DrcDiscThtcErr(), PndFsmResponse::EmcEcal(), evtcnt, exp(), fabs(), fApplyFilter, fBremsEnergy, fdbPdg, fElectronBrems, fEventInfo, fGenSplitOffs, fMcCandidates, fMergeNeutralClusters, fMergeProbPar, fNAccept, fPidArrayList, fPidChargedCand, fPidChargedProb, fPidNeutralCand, fPidNeutralProb, fPropagate, fRand, fspo, fUseFlatCovMatrix, fVb, RhoCandList::GetLength(), PndStack::GetNtrack(), PndStack::GetParticle(), i, RhoFactory::Instance(), PndFsmResponse::LHElectron(), PndFsmResponse::LHKaon(), PndFsmResponse::LHMuon(), PndFsmResponse::LHPion(), PndFsmResponse::LHProton(), PndFsmResponse::m2(), mom, PndFsmResponse::MuoIron(), PndFsmResponse::MvddEdx(), PndFsmTrack::p4(), phot, pos, PndStack::PushTrack(), RhoFactory::Reset(), PndFsmResponse::RichThtc(), PndFsmResponse::RichThtcErr(), PndEventInfo::SetCharged(), PndEventInfo::SetCmFrame(), PndPidCandidate::SetCov7(), PndPidCandidate::SetDiscNumberOfPhotons(), PndPidCandidate::SetDiscThetaC(), PndPidCandidate::SetDiscThetaCErr(), PndPidCandidate::SetDrcNumberOfPhotons(), PndPidCandidate::SetDrcThetaC(), PndPidCandidate::SetDrcThetaCErr(), PndPidProbability::SetElectronPdf(), PndPidCandidate::SetEmcCalEnergy(), PndPidCandidate::SetEnergy(), PndPidProbability::SetIndex(), PndEventInfo::SetIPTruth(), PndPidProbability::SetKaonPdf(), PndPidCandidate::SetLastHit(), RhoCandidate::SetMarker(), PndPidCandidate::SetMcIndex(), RhoCandidate::SetMcTruth(), PndPidCandidate::SetMomentum(), PndPidCandidate::SetMuoIron(), PndPidProbability::SetMuonPdf(), PndPidCandidate::SetMvdDEDX(), PndEventInfo::SetNeutrals(), PndPidProbability::SetPionPdf(), PndPidProbability::SetProtonPdf(), PndPidCandidate::SetRichNumberOfPhotons(), PndPidCandidate::SetRichThetaC(), PndPidCandidate::SetRichThetaCErr(), PndPidCandidate::SetSttMeanDEDX(), PndPidCandidate::SetTofM2(), RhoCandidate::SetTrackNumber(), RhoCandidate::SetType(), smearTrack(), PndFsmTrack::startVtx(), PndFsmTrack::stopVtx(), PndFsmResponse::SttdEdx(), and t.

{
  int nCharged = 0;
  int nNeutral = 0;

  if ((++evtcnt)%100==0)
    cout <<"[PndFastSim] evt "<<evtcnt<<endl;

  PndStack *fStack=(PndStack*)gMC->GetStack();
  Int_t nTracks=fStack->GetNtrack();
  
  RhoFactory::Instance()->Reset();
  // Reset output array
  if (fMcCandidates->GetEntriesFast() != 0)  fMcCandidates->Clear("C");
  if (fPidChargedCand->GetEntriesFast() != 0)  fPidChargedCand->Clear("C");
  if (fPidNeutralCand->GetEntriesFast() != 0)  fPidNeutralCand->Clear("C");
  if (fPidChargedProb->GetEntriesFast() != 0)  fPidChargedProb->Clear("C");
  if (fPidNeutralProb->GetEntriesFast() != 0)  fPidNeutralProb->Clear("C");
  //if (fMicroCandidates->GetEntriesFast() != 0) fMicroCandidates->Clear("C");
  if (fEventInfo->GetEntriesFast() != 0) fEventInfo->Clear("C");
  for(std::map<TString,TClonesArray*>::iterator iter=fPidArrayList.begin();iter!=fPidArrayList.end();iter++)
  {
    if(iter->second->GetEntriesFast() != 0) iter->second->Clear("C");
  }

  TClonesArray &mctracks       = *fMcCandidates;

  TClonesArray &chrgCandidates = *fPidChargedCand;  // Charged Candidates
  TClonesArray &neutCandidates = *fPidNeutralCand;  // Neutral Candidates

  TClonesArray &chrgProbs      = *fPidChargedProb;  // PID for charged Cands
  TClonesArray &neutProbs      = *fPidNeutralProb;  // PID for neutral Cands

  //TClonesArray &microCandidates = *fMicroCandidates;
  TClonesArray &evtInfo         = *fEventInfo;

  if (fVb)cout <<"number of tracks **** "<< nTracks <<endl;


  RhoCandList l, lfilt;
  TLorentzVector McSumP4(0,0,0,0);
  TVector3 McAvgVtx(0,0,0);
  
  if (fApplyFilter)
  {
    // extra loop for the filters
    for (Int_t iTrack=0; iTrack<nTracks; iTrack++) 
    {
      TParticle *t = fStack->GetParticle(iTrack);
      int pdg = abs(t->GetPdgCode());
      if (!(pdg==11 || pdg==13 || pdg==211 || pdg==321 || pdg==2212 || pdg==22)) continue;
       
      TLorentzVector p4(t->Px(),t->Py(),t->Pz(),t->Energy());
      TParticlePDG* part = fdbPdg->GetParticle(t->GetPdgCode());
      double charge=0;//safety against unknown pdgcodes, might scrw up the charge
      if (part) charge=part->Charge();
      if (fabs(charge)>2) charge/=3.;
      
      RhoCandidate c(p4, charge);
      c.SetType(t->GetPdgCode());
      c.SetMarker(lfilt.GetLength());
      lfilt.Add(&c);
    }
    
    int errac = acceptFilters(lfilt);
    
    if (errac>0)
    {
      if (fVb>0) 
      {
        cout <<"PndFastSim Filter reject ev="<< evtcnt<<" with code="<<errac<<endl;
        cout <<"Filter list"<<endl;
        for (int i=0;i<lfilt.GetLength();++i)
        {
          cout <<i<<" : "<<lfilt[i]->PdgCode();
          cout <<" ("<<lfilt[i]->P4().X()<<","<<lfilt[i]->P4().Y()<<","<<lfilt[i]->P4().Z()<<","<<lfilt[i]->P4().E()<<")"<<endl;
        }
      }
    
      RhoFactory::Instance()->Reset();
      return;
    }
    fNAccept++;
  } // filter done

  for (Int_t iTrack=0; iTrack<nTracks; iTrack++) 
  {

    // Get the MCTrack information
    Int_t mcsize = mctracks.GetEntriesFast();
    Int_t chcandsize = chrgCandidates.GetEntriesFast();
    Int_t neucandsize = neutCandidates.GetEntriesFast();
    //Int_t miccandsize = microCandidates.GetEntriesFast();

    TParticle *t = fStack->GetParticle(iTrack);
    if (fVb>1) t->Print();

    TLorentzVector p4(t->Px(),t->Py(),t->Pz(),t->Energy());
    TVector3 stvtx(t->Vx(),t->Vy(),t->Vz());

    int pdg = t->GetPdgCode();
  
    // simulate bremsstrahlung for electrons and add photon on stack
    if (abs(pdg)==11 && fElectronBrems)
    {
      // probability for bremsstrahlung was estimated from Full Sim to about 32%
      if (fRand->Rndm()<0.32)
      {
        // get random energy loss and compute residual momentum (as equivalent to kinetic energy)
        double loss  = fBremsEnergy->GetRandom(0.03,0.9);
    
        // modify electron momentum mag (not the direction at the moment)
        p4.SetVectM(p4.Vect()*(1.0-loss),5.11e-4);
        TLorentzVector phot;
        phot.SetVectM(p4.Vect()*loss, 0.0);
    
        // add an additional photon to the stack with the energy
        fStack->PushTrack(0, iTrack, 22,                    // Int_t toBeDone, Int_t parentID, Int_t pdgCode
                  phot.X(), phot.Y(), phot.Z(),   // Double_t px, Double_t py, Double_t pz,
                  phot.E(), 0., 0.,         // Double_t e, Double_t vx, Double_t vy,
                  0. , 0., 0.,            // Double_t vz, Double_t time, Double_t polx,
                  0., 0., kPPrimary,        // Double_t poly, Double_t polz, TMCProcess proc,
                  nTracks, 0., 0.);         // Int_t& ntr, Double_t weight, Int_t is
    
        nTracks=fStack->GetNtrack();
      }
    }

    // shall we add some parametrized split offs?
    if (fGenSplitOffs)
    {
      int type=-1;
    
      if (abs(pdg) == 11) type=0;
      else if (abs(pdg) == 211) type=2;
      else if (abs(pdg) == 321) type=3;
      else if (abs(pdg) == 2212) type=4;
      
      if (type>0)
      {
    
        //number of split offs?
        int numSP=(int)fspo[type][3]->GetRandom();
    
        if (fVb) cout <<" -I- (PndFastSim::Exec) - creating "<<numSP
        <<" split offs for particle with type "<<type<<endl;
    
        for (int ii=0;ii<numSP;ii++)
        {
          TLorentzVector lv(p4);
    
          double mom   = fspo[type][0]->GetRandom();
          double dphi  = fspo[type][1]->GetRandom();
          double dtht  = fspo[type][2]->GetRandom();
    
          lv.SetPhi(lv.Phi()+dphi);
          lv.SetTheta(lv.Theta()+dtht);
          lv.SetRho(mom);
          lv.SetE(lv.P());
    
          // add an additional photon to the stack with the energy
          fStack->PushTrack(0, iTrack, 22,                    // Int_t toBeDone, Int_t parentID, Int_t pdgCode
                  lv.X(), lv.Y(), lv.Z(),   // Double_t px, Double_t py, Double_t pz,
                  lv.E(), 0., 0.,         // Double_t e, Double_t vx, Double_t vy,
                  0. , 0., 0.,            // Double_t vz, Double_t time, Double_t polx,
                  0., 0., kPPrimary,        // Double_t poly, Double_t polz, TMCProcess proc,
                  nTracks, 0., 0.);         // Int_t& ntr, Double_t weight, Int_t is
    
          nTracks=fStack->GetNtrack();
        } // split off loop
      }
    }// generate split offs

    //TLorentzVector vtx(stvtx,t->T());
    TParticlePDG* part = fdbPdg->GetParticle(t->GetPdgCode());
    double charge(0);//safety against unknown pdgcodes, might scrw up the charge
    if(part) charge=part->Charge();
    if (fabs(charge)>2) charge/=3.;

    PndFsmTrack *ft=new PndFsmTrack(p4,stvtx,stvtx,charge,t->GetPdgCode(),iTrack+1);
    //PndFsmTrack ft(p4,stvtx,stvtx,charge,t->GetPdgCode(),iPoint+1);

    // store a plain copy of the mc track to the file
    RhoCandidate *pmc=new (mctracks[mcsize]) RhoCandidate(ft->p4(),ft->charge());
    pmc->SetMcTruth(pmc);
    pmc->SetPos(ft->startVtx());
    pmc->SetType(t->GetPdgCode());
    // write some ideal pid lhs
    bool pdgcheck = false;
    switch(abs(t->GetPdgCode())) {
      case 22:                          pdgcheck = true; break;
      case 11:   pmc->SetPidInfo(0, 1); pdgcheck = true; break;
      case 13:   pmc->SetPidInfo(1, 1); pdgcheck = true; break;
      case 211:  pmc->SetPidInfo(2, 1); pdgcheck = true; break;
      case 321:  pmc->SetPidInfo(3, 1); pdgcheck = true; break;
      case 2212: pmc->SetPidInfo(4, 1); pdgcheck = true; break;
    }

    McSumP4+=ft->p4();
    McAvgVtx+=ft->startVtx();

    if (pdgcheck) // only consider final state particles
    {
      // smear and cut the track according to the detector setup
      bool smeared = smearTrack(ft, chcandsize);
      if (smeared)
      {
        RhoVector3Err *svtx=new RhoVector3Err(ft->startVtx());
        TLorentzVector miclv=ft->p4();
        TVector3 pos=ft->startVtx();
        TVector3 lastpos=ft->stopVtx();

        // assign pion mass to all charged and 0 to all neutral cands
        if (fabs(ft->charge())>0.001)
        {
          miclv.SetVectM(miclv.Vect(),fdbPdg->GetParticle(211)->Mass());
          nCharged++;
        }
        else
        {
          miclv.SetVectM(miclv.Vect(),0.0);
          nNeutral++;
        }

        PndPidCandidate *pidCand=0;
        PndPidProbability *pidProb=0;

        if (fabs(ft->charge())>1e-6)
        {
          pidCand = new (chrgCandidates[chcandsize]) PndPidCandidate((Int_t)ft->charge(),pos,miclv);
          pidProb = new (chrgProbs[chcandsize]) PndPidProbability();
        }
        else
        {
          // flag for merge neutral clusters
          bool merged = false;
       
          // if two neutrals have small angle difference alpha, merge their clusters with a certain probability 1-exp(-a*alpha)
          if (fMergeNeutralClusters)
          {
            // loop through old gammas
            for (int i=0; i<neucandsize;++i)
            {
              TLorentzVector nlv = ((PndPidCandidate*) neutCandidates[i])->GetLorentzVector();
              double openang = nlv.Angle(miclv.Vect())*57.2958;
              if (fRand->Rndm()>(1-exp(-fMergeProbPar*openang)))
              {
                double mergeE = nlv.E()+miclv.E();
                TVector3 mergeV = nlv.Vect()+miclv.Vect();
                mergeV *= mergeE/mergeV.Mag();
             
                PndPidCandidate* mergedCand = (PndPidCandidate*) neutCandidates[i];
                mergedCand->SetMomentum(mergeV);
                mergedCand->SetEnergy(mergeE);
                mergedCand->SetMcIndex(-1); // remove MC truth match
             
                merged = true;
                
                // exit loop, if mergeing happend
                i=neucandsize;
              }
            }
          }

          // if the new gamma wasn't merged to another, just add it as usual
          if (!merged)
          {
            pidCand = new (neutCandidates[neucandsize]) PndPidCandidate((Int_t)ft->charge(),pos,miclv);
            pidCand->SetLastHit(lastpos);
            pidProb = new (neutProbs[neucandsize]) PndPidProbability();
          }
        }

        if (pidProb)
        {
          pidProb->SetElectronPdf(ft->detResponse()->LHElectron());
          pidProb->SetMuonPdf(ft->detResponse()->LHMuon());
          pidProb->SetPionPdf(ft->detResponse()->LHPion());
          pidProb->SetKaonPdf(ft->detResponse()->LHKaon());
          pidProb->SetProtonPdf(ft->detResponse()->LHProton());
          pidProb->SetIndex(chcandsize);
        }
        if (pidCand)
        {
          pidCand->SetMcIndex(iTrack);
          pidCand->SetMvdDEDX( ft->detResponse()->MvddEdx() );
     
          //pidCand->SetMvdDEdxErr( ft->detResponse()->MvddEdxErr() );
          pidCand->SetSttMeanDEDX( ft->detResponse()->SttdEdx() );
          //pidCand->SetSttDEdxErr( ft->detResponse()->SttdEdxErr() );
          pidCand->SetTofM2( ft->detResponse()->m2() );
          //pidCand->SetTofM2Err( ft->detResponse()->m2Err() );
          pidCand->SetDrcThetaC( ft->detResponse()->DrcBarrelThtc() );
          pidCand->SetDrcThetaCErr( ft->detResponse()->DrcBarrelThtcErr() );
          pidCand->SetDrcNumberOfPhotons(0);
          pidCand->SetDiscThetaC( ft->detResponse()->DrcDiscThtc() );
          pidCand->SetDiscThetaCErr( ft->detResponse()->DrcDiscThtcErr() );
          pidCand->SetDiscNumberOfPhotons(0);
          pidCand->SetRichThetaC( ft->detResponse()->RichThtc() );
          pidCand->SetRichThetaCErr( ft->detResponse()->RichThtcErr() );
          pidCand->SetRichNumberOfPhotons(0);
          pidCand->SetEmcCalEnergy(ft->detResponse()->EmcEcal() );
          pidCand->SetMuoIron(ft->detResponse()->MuoIron() );
          RhoCandidate tcand(ft->p4(),ft->charge(),svtx);
          tcand.SetTrackNumber(chcandsize);
     
          if( (fPropagate||fUseFlatCovMatrix))// && fabs(ft->charge())>1e-6)
          {
            tcand.SetCov7(ft->Cov7());
            pidCand->SetCov7( ft->Cov7() );
          }
          l.Add(&tcand);
        }
        delete svtx;
 
      }// smeartrack
    }
    delete ft;
  }//trackloop

  McAvgVtx*=1./(double)nTracks;

  PndEventInfo *eventInfo=new (evtInfo[evtInfo.GetEntriesFast()]) PndEventInfo();

  eventInfo->SetIPTruth(McAvgVtx);
  eventInfo->SetCmFrame(McSumP4);
  eventInfo->SetCharged(nCharged);
  eventInfo->SetNeutrals(nNeutral);

  //  TEventShape shape(l);
  //  eventInfo->SetEventShape(shape);

}

void PndFastSim::Finish ( )

virtual

Definition at line 599 of file PndFastSim.cxx.

References evtcnt, fApplyFilter, fInvMassFilter, fInvMassMax, fInvMassMin, fInvMassMult, fMultMax, fMultMin, fNAccept, i, and TString.

{
  TString multnames[6] = {"ch+","ch-", "gam", "pi0", "ks", "eta"};
  if (fApplyFilter)
  {       
    for (int i=0;i<6;++i)
    {
      if (fMultMin[i]>0 || fMultMax[i]<1000)
      std::cout <<"*** Filtering Info: "<<fMultMin[i]<<" <= "<<multnames[i].Data() <<" <= "<<fMultMax[i]<<endl;
    }
    std::cout <<"*** Filtering Info: "<<fInvMassMin<<" < m("<<fInvMassFilter.Data()<<") < "<<fInvMassMax<<" with N="<<fInvMassMult<<endl;
    std::cout <<"*** Filtering Info: "<< fNAccept <<"/"<<evtcnt<<" accepted by filters."<<endl;
  }
}

InitStatus PndFastSim::Init ( )

virtual

Virtual method Init

Definition at line 158 of file PndFastSim.cxx.

References evtcnt, fBremsEnergy, fDetList, fEta, fRho, fVb, PndFsmAbsDet::print(), and Register().

                            {

  if (fVb>3) cout << " Inside the Init function****" << endl;

  Register();
  if (fVb)
  {
    cout <<"\n\n******   DETECTOR SETUP SUMMARY    ***************\n\n";
    for (FsmAbsDetList::iterator iter=fDetList.begin();iter!=fDetList.end(); iter++)
    {
      cout<<endl<<"----------------------------"<<endl;
      PndFsmAbsDet *det=*iter;
      det->print(std::cout);
    }
    cout <<"\n\n******   DETECTOR SETUP SUMMARY    ***************\n\n";
  }

  evtcnt=0;

  // for the time being, this is the matrix of correlation
  // coefficients, it is later scaled by the track errors
  //d0                 phi0                omega               z0                  dandip
  fRho(0,0)= 1;        fRho(0,1)=-0.9243;  fRho(0,2)= 0.3087;  fRho(0,3)=-0.01743; fRho(0,4)= 0.009165; // d0
  fRho(1,0)=-0.9243;   fRho(1,1)= 1;       fRho(1,2)=-0.4189;  fRho(1,3)=-0.00552; fRho(1,4)=-0.00873;  // phi0
  fRho(2,0)= 0.3087;   fRho(2,1)=-0.4189;  fRho(2,2)= 1;       fRho(2,3)= 0.02094; fRho(2,4)=-0.01742;  // omega
  fRho(3,0)=-0.01743;  fRho(3,1)=-0.00552; fRho(3,2)= 0.02094; fRho(3,3)= 1;       fRho(3,4)=-0.9327;   // z0
  fRho(4,0)= 0.009165; fRho(4,1)=-0.00873; fRho(4,2)=-0.01742; fRho(4,3)=-0.9327;  fRho(4,4)= 1;        // tandip
  // and this is the square root of fRho
  // needed to correlate the track params
  //d0                 phi0                 omega                z0                  dandip
  fEta(0,0)= 1;                                                                                       // d0
  fEta(1,0)=-0.9243;   fEta(1,1)= 0.3817;                                                             // phi0
  fEta(2,0)= 0.3087;   fEta(2,1)=-0.35;     fEta(2,2)= 0.8844;                                        // omega
  fEta(3,0)=-0.01743;  fEta(3,1)=-0.05667;  fEta(3,2)= 0.007335; fEta(3,3)= 0.9982;                   // z0
  fEta(4,0)= 0.009165; fEta(4,1)=-6.781e-4; fEta(4,2)=-0.02316;  fEta(4,3)=-0.9341; fEta(4,4)=0.3562; // tandip

  // parametrization for bremsstrahlung (based on Crystal Ball function tail)
  fBremsEnergy = new TF1("fBremsEnergy","[0]*pow([3]/[4],[3])*exp(-0.5*[4]^2)/pow((x-[1])/[2]+[3]/[4]-[4],[3])");
  fBremsEnergy->SetParameters(1,0.005,0.0311,1.05,1.04);
  fBremsEnergy->SetRange(0.03,0.9); // valid between 3% and 90% energy loss through bremsstrahlung

  // Create and register output array
  cout << "-I- PndFastSim: Intialization successfull" << endl;

  return kSUCCESS;
}

bool PndFastSim::MergeNeutralClusters ( bool  merge = true, double  par = 0.389  )

inline

Definition at line 61 of file PndFastSim.h.

References fMergeNeutralClusters, fMergeProbPar, merge(), and par.

Referenced by prod_fsim(), quickfsimana(), simfast(), simfast_opt(), and tut_fastsim().

{fMergeNeutralClusters=merge; fMergeProbPar=par; return true;}

void PndFastSim::Register

(

)

Definition at line 120 of file PndFastSim.cxx.

References detname, PndFsmAbsDet::detName(), PndFsmAbsDet::doesPid(), fDetList, fEventInfo, fMcCandidates, fPersist, fPidArrayList, fPidChargedCand, fPidChargedProb, fPidNeutralCand, fPidNeutralProb, and TString.

Referenced by Init().

                          {
  //---

  fMcCandidates = new TClonesArray("RhoCandidate");
  FairRootManager::Instance()->Register("PndMcTracks","FastSim", fMcCandidates, fPersist);

  fPidChargedCand = new TClonesArray("PndPidCandidate");
  FairRootManager::Instance()->Register("PidChargedCand","FastSim", fPidChargedCand, fPersist);

  fPidNeutralCand = new TClonesArray("PndPidCandidate");
  FairRootManager::Instance()->Register("PidNeutralCand","FastSim", fPidNeutralCand, fPersist);

  fPidChargedProb = new TClonesArray("PndPidProbability");
  FairRootManager::Instance()->Register("PidChargedProbability","FastSim", fPidChargedProb, fPersist);

  fPidNeutralProb = new TClonesArray("PndPidProbability");
  FairRootManager::Instance()->Register("PidNeutralProbability","FastSim", fPidNeutralProb, fPersist);

  fEventInfo = new TClonesArray("PndEventInfo");
  FairRootManager::Instance()->Register("PndEventSummary","FastSim", fEventInfo, fPersist);

  for (FsmAbsDetList::iterator iter=fDetList.begin();iter!=fDetList.end(); iter++)
  {
    PndFsmAbsDet *det=*iter;
    if(!det->doesPid()) continue;
    TString detname = det->detName();
    TString arrayname=detname;
    arrayname+="Probability";
    TClonesArray* tmparray = new TClonesArray("PndPidProbability");
    FairRootManager::Instance()->Register(arrayname.Data(),"FastSim", tmparray, fPersist);
    fPidArrayList[detname]=tmparray;
    //std::cout<<"registered pid TCA with name "<<detname.Data()<<std::endl;
  }
}

void PndFastSim::SetFlatCovMatrix ( PndFsmTrack *  t, double  dp = 0., double  dtheta = 0., double  dphi = 0., double  dE = 0., double  dx = 0., double  dy = 0., double  dz = 0.  )

private

Definition at line 1109 of file PndFastSim.cxx.

References PndFsmTrack::charge(), cos(), dE, dtheta, dx, dy, dz, fabs(), p, PndFsmTrack::p4(), PndFsmTrack::SetP4Cov(), PndFsmTrack::SetVCov(), and sin().

Referenced by cutAndSmear().

{
  TLorentzVector lv=t->p4();

  double st=sin(lv.Theta());
  double ct=cos(lv.Theta());
  double sf=sin(lv.Phi());
  double cf=cos(lv.Phi());
  double p=lv.P();
  double e=lv.E();

  //printf("FastSim covariance test: dp=%f,  dtheta=%f,  dphi=%f,  dE=%f,  dx=%f,  dy=%f,  dz=%f\n", dp,  dtheta,  dphi,  dE,  dx,  dy,  dz);

  TMatrixD jacobian(4,3);

  if(fabs(t->charge())>1e-6)
  {
  jacobian(0,0) = st*cf;
    jacobian(1,0) = st*sf;
    jacobian(2,0) = ct;
    jacobian(3,0) = (e>0) ? p/e : 0.;
  } else { // no direct momentum measurement of neutrals
    jacobian(0,0) = st*cf*e/p;
    jacobian(1,0) = st*sf*e/p;
    jacobian(2,0) = ct*e/p;
    jacobian(3,0) = 1.;
  }
  jacobian(0,1) = p*ct*cf;
  jacobian(1,1) = p*ct*sf;
  jacobian(2,1) = -p*st;
  jacobian(3,1) = 0.;
  jacobian(0,2) = -p*st*sf;
  jacobian(1,2) = p*st*cf;
  jacobian(2,2) = 0.;
  jacobian(3,2) = 0.;

  TMatrixDSym covPol(3);
  if(fabs(t->charge())>1e-6) covPol(0,0)=dp*dp;
  else covPol(0,0)=dE*dE;

  covPol(1,1)=dtheta*dtheta;
  covPol(2,2)=dphi*dphi;

  TMatrixD jcov(jacobian,TMatrixD::kMult,covPol);
  TMatrixD covCar(jcov,TMatrixD::kMultTranspose,jacobian);

//  cout<<"Lorentzvector: ";
//  lv.Print();
//  cout<<"Polar covariance: ";
//  covPol.Print();
//  cout<<"Jacobian: ";
//  jacobian.Print();
//  //cout<<"Jacobian*covPol: ";
//  //jcov.Print();
//  cout<<"Kartesian covariance: ";
//  covCar.Print();

  t->SetP4Cov(covCar);

  TMatrixD covV(3,3);
  covV(0,0) = dx*dx;
  covV(0,1) = 0.;
  covV(0,2) = 0.;
  covV(1,0) = 0.;
  covV(1,1) = dy*dy;
  covV(1,2) = 0.;
  covV(2,0) = 0.;
  covV(2,1) = 0.;
  covV(2,2) = dz*dz;

  t->SetVCov(covV);

  return;
}

void PndFastSim::SetInvMassFilter	(	TString	filter,
		double	min,
		double	max,
		int	mult = 1
	)

Definition at line 373 of file PndFastSim.cxx.

References fApplyFilter, fChargeConj, fCombIndex, fCombMult, fInvMassFilter, fInvMassMax, fInvMassMin, fInvMassMult, i, idx, max(), min(), mult, and TString.

Referenced by prod_fsim(), quickfsimana(), and simfast_opt().

{
  fInvMassFilter=filter; 
  fInvMassMin=min; 
  fInvMassMax=max; 
  fInvMassMult=mult; 
  fApplyFilter=true;
  fCombMult = 0;
  
  TString wk=filter;
  if (wk.EndsWith("cc"))
  {
    fChargeConj = true;
    wk=wk(0,wk.Length()-3);
  }
  wk+=" ";
  
  // chop the configuration string in pieces 
  // coding is: 0+=e+, 1+=mu+, ... , 4+=p+ (& cc), gm=gamma 
  // list indices: 0:e+ 1:e-, 2:mu+, ... 9:p-, 10:gamma, 11:pi0(gg), 12:KS, 13:eta(gg)
  while (wk.Length()>0 && fCombMult<5)
  {
     int delim = wk.Index(" ");
     int idx=0;
     TString tok=wk(0,delim);
     cout <<tok<<" ";
     if (tok=="gam") idx=10;
     else if (tok=="pi0") idx=11;
     else if (tok=="ks") idx=12;
     else if (tok=="eta") idx=13;
     else if (tok.BeginsWith("e")) idx=0;
     else if (tok.BeginsWith("mu")) idx=2;
     else if (tok.BeginsWith("pi")) idx=4;
     else if (tok.BeginsWith("k")) idx=6;
     else if (tok.BeginsWith("p")) idx=8;

     if (tok.EndsWith("-")) idx++;
     
     fCombIndex[fCombMult]=idx;
     fCombMult++;
     
     wk=wk(delim+1,1000);
  }
  cout <<"Inv Mass Filter combines:";
  for (int i=0;i<fCombMult;++i) cout <<fCombIndex[i]<<" ";
  if (fChargeConj) cout << "  with c.c.";
  cout <<endl;
}

void PndFastSim::SetMultFilter	(	TString	type,
		int	min,
		int	max = 1000
	)

Definition at line 347 of file PndFastSim.cxx.

References fMultMax, fMultMin, i, max(), and min().

Referenced by simfast_opt().

{ 
  int i=0;
  if (type=="+") i=0;
  else if (type=="-") i=1;
  else if (type=="gam") i=2;
  else if (type=="pi0") i=3;
  else if (type=="ks") i=4;
  else if (type=="eta") i=5;
  else cout <<" WARNING :  Unknown type '"<<type.Data()<< "' for muliplicity filter!"<<endl; 
  
  fMultMin[i] = min;
  fMultMax[i] = max;
}

void PndFastSim::SetParContainers ( )

privatevirtual

Get parameter containers

Definition at line 205 of file PndFastSim.cxx.

References run.

                                  {

  // Get run and runtime database
  FairRun* run = FairRun::Instance();
  if ( ! run ) Fatal("SetParContainers", "No analysis run");

  FairRuntimeDb* db = run->GetRuntimeDb();
  if ( ! db ) Fatal("SetParContainers", "No runtime database");


}

void PndFastSim::SetSeed

(

unsigned int

seed = 65539

)

Definition at line 218 of file PndFastSim.cxx.

References fRand.

                                          {
  fRand->SetSeed(seed);
}

void PndFastSim::SetUseFlatCov ( bool  v = true )

inline

Definition at line 64 of file PndFastSim.h.

References fUseFlatCovMatrix, and v.

Referenced by prod_fsim(), quickfsimana(), simfast(), simfast_opt(), and tut_fastsim().

{fUseFlatCovMatrix=v;};

void PndFastSim::SetVerbosity ( int  vb )

inline

Definition at line 59 of file PndFastSim.h.

References fVb.

Referenced by prod_fsim(), QAmacro_fastsim_1(), quickfsimana(), run_fast(), simfast(), simfast_cmp(), simfast_dpm(), simfast_dpm_cmp(), simfast_opt(), simfast_single_allpid(), simfast_singletracks(), and tut_fastsim().

{fVb=vb;}

void PndFastSim::smearEnergy ( PndFsmTrack *  t, double  dE  )

private

Definition at line 1185 of file PndFastSim.cxx.

References PndFsmTrack::charge(), fabs(), fRand, m, PndFsmTrack::p4(), PndFsmTrack::setP4(), and sqrt().

Referenced by cutAndSmear().

{
  TLorentzVector p4=t->p4();
  double m=t->p4().M();

  //  if (t->pdt()->lundId()==22) //gammas are always on mass shell
  if (fabs(t->charge()) < 0.1 ) //gammas are always on mass shell
  {
    //    double rnd = pRand->Gaus(0.,dE);
    double rnd = fRand->Gaus(0. , dE);

    double newE = rnd + p4.E();

    p4.SetVectM(p4.Vect()*(newE/p4.E()) , 0.0);
  }
  else
  {
    double newE = fRand->Gaus(0.0,dE) + p4.E();
    double newP = sqrt(newE*newE - m*m);

    p4.SetE(newE);
    p4.SetVectMag(p4.Vect(),newP);
  }

  t->setP4(p4);
}

void PndFastSim::smearM ( PndFsmTrack *  t, double  dm  )

private

Definition at line 1242 of file PndFastSim.cxx.

References PndFsmTrack::p4(), and PndFsmTrack::setP4().

Referenced by cutAndSmear().

{
  TLorentzVector p4=t->p4();
  //  double newM = p4.m() + RandGauss::shoot(0.,dm);
  double newM=p4.M() + dm;

  p4.SetVectM(p4.Vect(),newM);

  t->setP4(p4);
}

void PndFastSim::smearM2 ( PndFsmTrack *  t, double  m2  )

private

Definition at line 1254 of file PndFastSim.cxx.

References PndFsmTrack::setMass2().

Referenced by cutAndSmear().

{

  t->setMass2(m2);
}

void PndFastSim::smearMomentum ( PndFsmTrack *  t, double  dp  )

private

Definition at line 1213 of file PndFastSim.cxx.

References fRand, PndFsmTrack::p4(), and PndFsmTrack::setP4().

Referenced by cutAndSmear().

{
  TLorentzVector p4=t->p4();
  double newP = p4.Vect().Mag() + fRand->Gaus(0.0,dp);
  p4.SetVectM(p4.Vect().Unit()*newP,t->p4().M());
  t->setP4(p4);
}

void PndFastSim::smearMvddEdx ( PndFsmTrack *  t, double  dedx  )

private

Definition at line 1261 of file PndFastSim.cxx.

References PndFsmTrack::setMvddEdX().

Referenced by cutAndSmear().

{

  t->setMvddEdX(MvddEdx);
}

void PndFastSim::smearPhi ( PndFsmTrack *  t, double  dphi  )

private

Definition at line 1232 of file PndFastSim.cxx.

References fRand, PndFsmTrack::p4(), and PndFsmTrack::setP4().

Referenced by cutAndSmear().

{
  TLorentzVector p4=t->p4();
  double newPhi = p4.Phi() + fRand->Gaus(0.,dphi);
  p4.SetPhi(newPhi);

  t->setP4(p4);
}

void PndFastSim::smearSttdEdx ( PndFsmTrack *  t, double  dedx  )

private

Definition at line 1268 of file PndFastSim.cxx.

References PndFsmTrack::setSttdEdX().

Referenced by cutAndSmear().

{

  t->setSttdEdX(SttdEdx);
}

void PndFastSim::smearTheta ( PndFsmTrack *  t, double  dtheta  )

private

Definition at line 1222 of file PndFastSim.cxx.

References fRand, PndFsmTrack::p4(), and PndFsmTrack::setP4().

Referenced by cutAndSmear().

{
  TLorentzVector p4=t->p4();
  double newTheta = p4.Theta() + fRand->Gaus(0.,dtheta);
  p4.SetTheta(newTheta);

  t->setP4(p4);
}

void PndFastSim::smearTpcdEdx ( PndFsmTrack *  t, double  dedx  )

private

bool PndFastSim::smearTrack ( PndFsmTrack *  t, int  idx = -1  )

private

Definition at line 951 of file PndFastSim.cxx.

References PndFsmTrack::charge(), cutAndSmear(), PndFsmResponse::detector(), detname, PndFsmAbsDet::detName(), PndFsmAbsDet::doesPid(), fabs(), fDetList, fPidArrayList, PndFsmResponse::LHElectron(), PndFsmResponse::LHKaon(), PndFsmResponse::LHMuon(), PndFsmResponse::LHPion(), PndFsmResponse::LHProton(), PndFsmAbsDet::respond(), PndFsmTrack::setDetResponse(), PndPidProbability::SetIndex(), mrfdata_8b_error::success, sumResponse(), and TString.

Referenced by Exec().

{


  FsmResponseList responseList;

  for (FsmAbsDetList::iterator iter=fDetList.begin();iter!=fDetList.end(); iter++)
  {
    PndFsmAbsDet *det=*iter;
    //if (!det) {cout <<"--------------------------> outch"<<endl;continue;}

    PndFsmResponse *respo=det->respond(t);

    if (respo) responseList.push_back(respo);
  }

  PndFsmResponse *allResponse=sumResponse(responseList);

  t->setDetResponse(allResponse);

  bool success = cutAndSmear(t);

  if(success && fabs(t->charge())>1e-6)
  { // create dummy PID info for all detectors, then fill it with reason later
    for(std::map<TString, TClonesArray*>::iterator pidit=fPidArrayList.begin() ; pidit != fPidArrayList.end() ; pidit++)
    {
      TClonesArray* myPidarray = pidit->second;
      if (!myPidarray) Error("PndFastSim::smearTrack","Missing PidProb Array: \"%s\"",pidit->first.Data());
      if (myPidarray->GetEntriesFast() != chcandsize ) Warning("PndFastSim::smearTrack","unequal array sizes: cand array:%i  prob array \"%s\" :%i",chcandsize,pidit->first.Data(),myPidarray->GetEntriesFast());
      PndPidProbability *apidProb=new((*myPidarray)[chcandsize]) PndPidProbability();
      apidProb->SetIndex(chcandsize);
    }
  }

  for (FsmResponseList::iterator riter=responseList.begin(); riter!=responseList.end();riter++)
  {
    PndFsmResponse *resp=*riter;
    if (!resp) continue;

    if(success && fabs(t->charge())>1e-6&&resp->detector()->doesPid())
    { //save PID information only if particle is stored
      TString detname = resp->detector()->detName();
      TClonesArray* myPidarray = fPidArrayList[detname];
      if (!myPidarray) Error("PndFastSim::smearTrack","Failed accessing PidProb Array: \"%s\"",detname.Data());
      PndPidProbability *pidProb=(PndPidProbability*)myPidarray->At(chcandsize);
      if (!pidProb) Error("PndFastSim::smearTrack","Failed accessing PidProb Object number %i from array \"%s\"",chcandsize,detname.Data());
      {
        double rawLHe  = resp->LHElectron();
        double rawLHmu = resp->LHMuon();
        double rawLHpi = resp->LHPion();
        double rawLHK  = resp->LHKaon();
        double rawLHp  = resp->LHProton();

        double sumRaw = rawLHe+rawLHmu+rawLHpi+rawLHK+rawLHp;

        if (sumRaw!=0.)
        {
          pidProb->SetElectronPdf(rawLHe/sumRaw);
          pidProb->SetMuonPdf(rawLHmu/sumRaw);
          pidProb->SetPionPdf(rawLHpi/sumRaw);
          pidProb->SetKaonPdf(rawLHK/sumRaw);
          pidProb->SetProtonPdf(rawLHp/sumRaw);
        } else {
          pidProb->SetElectronPdf(0.2);
          pidProb->SetMuonPdf(0.2);
          pidProb->SetPionPdf(0.2);
          pidProb->SetKaonPdf(0.2);
          pidProb->SetProtonPdf(0.2);
        }
      }
    }
    // and now clean up!
    delete resp;
  }
  responseList.clear();

  return success;
}

void PndFastSim::smearVertex ( PndFsmTrack *  t, TVector3  dV  )

private

Definition at line 1275 of file PndFastSim.cxx.

References fRand, PndFsmTrack::setStartVtx(), and PndFsmTrack::startVtx().

Referenced by cutAndSmear().

{
  TVector3 vtx = t->startVtx();

  double newX = vtx.X() + fRand->Gaus( 0. , dV.X() );
  double newY = vtx.Y() + fRand->Gaus( 0. , dV.Y() );
  double newZ = vtx.Z() + fRand->Gaus( 0. , dV.Z() );

  vtx.SetX(newX);
  vtx.SetY(newY);
  vtx.SetZ(newZ);

  t->setStartVtx(vtx);
}

PndFsmResponse * PndFastSim::sumResponse ( FsmResponseList  respList )

private

Definition at line 1294 of file PndFastSim.cxx.

References dE, PndFsmResponse::dE(), PndFsmResponse::detected(), PndFsmResponse::detector(), PndFsmAbsDet::detName(), PndFsmResponse::dm(), PndFsmResponse::dp(), PndFsmResponse::dphi(), PndFsmResponse::DrcBarrelThtc(), PndFsmResponse::DrcBarrelThtcErr(), PndFsmResponse::DrcDiscThtc(), PndFsmResponse::DrcDiscThtcErr(), PndFsmResponse::dt(), dtheta, PndFsmResponse::dtheta(), PndFsmResponse::dV(), PndFsmResponse::EmcEcal(), fabs(), fVb, PndFsmResponse::LHElectron(), PndFsmResponse::LHKaon(), PndFsmResponse::LHMuon(), PndFsmResponse::LHPion(), PndFsmResponse::LHProton(), PndFsmResponse::m2(), m2(), PndFsmResponse::m2Err(), PndFsmResponse::MuoIron(), PndFsmResponse::MvddEdx(), PndFsmResponse::MvddEdxErr(), PndFsmResponse::print(), PndFsmResponse::RichThtc(), PndFsmResponse::RichThtcErr(), PndFsmResponse::setdE(), PndFsmResponse::setDetected(), PndFsmResponse::setdm(), PndFsmResponse::setdp(), PndFsmResponse::setdphi(), PndFsmResponse::setDrcBarrelThtc(), PndFsmResponse::setDrcDiscThtc(), PndFsmResponse::setdt(), PndFsmResponse::setdtheta(), PndFsmResponse::setdV(), PndFsmResponse::setEmcEcal(), PndFsmResponse::setLHElectron(), PndFsmResponse::setLHKaon(), PndFsmResponse::setLHMuon(), PndFsmResponse::setLHPion(), PndFsmResponse::setLHProton(), PndFsmResponse::setm2(), PndFsmResponse::setMuoIron(), PndFsmResponse::setMvddEdx(), PndFsmResponse::setRichThtc(), PndFsmResponse::setSttdEdx(), sqrt(), PndFsmResponse::SttdEdx(), PndFsmResponse::SttdEdxErr(), and val.

Referenced by smearTrack().

{

  bool detected=false;

  double dE=0.0;
  double dp=0.0;
  double dtheta=0.0;
  double dphi=0.0;
  double dt=0.0;
  double dm=0.0;

  double m2=0;
  double MvddEdx=0;
  double SttdEdx=0;
  double DrcDiscThtc=0;
  double DrcBarrelThtc=0;
  double RichThtc=0;
  double EmcEcal=0;
  double MuoIron=0;

  double m2Err=0;
  double MvddEdxErr=0;
  double SttdEdxErr=0;
  double DrcDiscThtcErr=0;
  double DrcBarrelThtcErr=0;
  double RichThtcErr=0;

  double dVx=0.0;
  double dVy=0.0;
  double dVz=0.0;

  double LH_e=1.0;
  double LH_mu=1.0;
  double LH_pi=1.0;
  double LH_K=1.0;
  double LH_p=1.0;

  double val=0.0;

  PndFsmResponse *allResponse=new PndFsmResponse();

  if (fVb>3) cout <<" *** SINGLE RESPONSES ***"<<endl<<"--------------------------------------"<<endl;

  for (FsmResponseList::iterator riter=respList.begin(); riter!=respList.end();riter++)
  {
    PndFsmResponse *resp=*riter;

    if ( fVb>3 ) resp->print(cout);

    if (resp->detector()->detName()=="IdealPid") continue; // don't use ideal PID

    detected = detected | resp->detected();

    if (resp->detected())
    {
      if (fabs(val = resp->dE()) > 1e-8)     dE += 1/(val*val);
      if (fabs(val = resp->dp()) > 1e-8)      dp += 1/(val*val);
      if (fabs(val = resp->dtheta())> 1e-8) dtheta += 1/(val*val);
      if (fabs(val = resp->dphi()) > 1e-8)   dphi += 1/(val*val);

      if (fabs(val = resp->dt()) > 1e-8)     dt += val*val;
      if (fabs(val = resp->dm()) > 1e-8)     dm =val;
      if (fabs (val = resp->m2()) > 1e-11)    m2=val;
      if (fabs (val = resp->MvddEdx()) > 1e-11)    MvddEdx=val;
      if (fabs (val = resp->SttdEdx()) > 1e-11)    SttdEdx=val;
      if (fabs (val = resp->DrcDiscThtc()) > 1e-11)   DrcDiscThtc=val;
      if (fabs (val = resp->DrcBarrelThtc()) > 1e-11)    DrcBarrelThtc=val;
      if (fabs (val = resp->RichThtc()) > 1e-11)    RichThtc=val;
      if (fabs (val = resp->EmcEcal()) > 1e-11)    EmcEcal=val;
      if (fabs (val = resp->MuoIron()) > 1e-11)    MuoIron=val;

      if (fabs (val = resp->m2Err()) > 1e-11)    m2Err=val;
      if (fabs (val = resp->MvddEdxErr()) > 1e-11)    MvddEdxErr=val;
      if (fabs (val = resp->SttdEdxErr()) > 1e-11)    SttdEdxErr=val;
      if (fabs (val = resp->DrcDiscThtcErr()) > 1e-11)   DrcDiscThtcErr=val;
      if (fabs (val = resp->DrcBarrelThtcErr()) > 1e-11)    DrcBarrelThtcErr=val;
      if (fabs (val = resp->RichThtcErr()) > 1e-11)    RichThtcErr=val;

      if (fabs (val = resp->dV().X()) > 1e-11) dVx += 1/(val*val);
      if (fabs (val = resp->dV().Y()) > 1e-11) dVy += 1/(val*val);
      if (fabs (val = resp->dV().Z()) > 1e-11) dVz += 1/(val*val);

      double rawLHe  = resp->LHElectron();
      double rawLHmu = resp->LHMuon();
      double rawLHpi = resp->LHPion();
      double rawLHK  = resp->LHKaon();
      double rawLHp  = resp->LHProton();

      double sumRaw = rawLHe+rawLHmu+rawLHpi+rawLHK+rawLHp;

      if (sumRaw>0) {
        rawLHe  /= sumRaw;
        rawLHmu /= sumRaw;
        rawLHpi /= sumRaw;
        rawLHK  /= sumRaw;
        rawLHp  /= sumRaw;
        LH_e  *= rawLHe;
        LH_mu *= rawLHmu;
        LH_pi *= rawLHpi;
        LH_K  *= rawLHK;
        LH_p  *= rawLHp;
      } else {
        LH_e  *= 0.2;
        LH_mu *= 0.2;
        LH_pi *= 0.2;
        LH_K  *= 0.2;
        LH_p  *= 0.2;
      }

      //here a weighted Likelihood evaluation has to be done

      /*
      if (val = rawLHe)  LH_e  == 0.0 ? LH_e  = val : LH_e  *= val;
      if (val = rawLHmu) LH_mu == 0.0 ? LH_mu = val : LH_mu *= val;
      if (val = rawLHpi) LH_pi == 0.0 ? LH_pi = val : LH_pi *= val;
      if (val = rawLHK)  LH_K  == 0.0 ? LH_K  = val : LH_K  *= val;
      if (val = rawLHp)  LH_p  == 0.0 ? LH_p  = val : LH_p  *= val;
      */
    }
  }

  double sumLH = LH_e + LH_mu + LH_pi + LH_K + LH_p;

  if (sumLH>0) {
    LH_e  /= sumLH;
    LH_mu /= sumLH;
    LH_pi /= sumLH;
    LH_K  /= sumLH;
    LH_p  /= sumLH;
  } else {
    LH_e  = 0.2;
    LH_mu = 0.2;
    LH_pi = 0.2;
    LH_K  = 0.2;
    LH_p  = 0.2;
  }

  allResponse->setDetected(detected);
  allResponse->setdE( dE>0. ? 1/sqrt(dE) : 0.0 );
  allResponse->setdp( dp>0. ? 1/sqrt(dp) : 0.0 );
  allResponse->setdtheta( dtheta>0. ? 1/sqrt(dtheta) : 0.0 );
  allResponse->setdphi( dphi>0. ? 1/sqrt(dphi) : 0.0 );
  allResponse->setdt( sqrt(dt) );
  allResponse->setdm(dm);

  allResponse->setm2(m2, m2Err);
  allResponse->setMvddEdx(MvddEdx,MvddEdxErr);
  allResponse->setSttdEdx(SttdEdx,SttdEdxErr);

  allResponse->setDrcDiscThtc(DrcDiscThtc,DrcDiscThtcErr);
  allResponse->setDrcBarrelThtc(DrcBarrelThtc,DrcBarrelThtcErr);
  allResponse->setRichThtc(RichThtc,RichThtcErr);
  allResponse->setEmcEcal(EmcEcal);
  allResponse->setMuoIron(MuoIron);

  if (dVx > 0.) dVx=1./sqrt(dVx); else dVx = 0.0;
  if (dVy > 0.) dVy=1./sqrt(dVy); else dVy = 0.0;
  if (dVz > 0.) dVz=1./sqrt(dVz); else dVz = 0.0;

  allResponse->setdV( dVx , dVy , dVz );

  allResponse->setLHElectron(LH_e);
  allResponse->setLHMuon(LH_mu);
  allResponse->setLHPion(LH_pi);
  allResponse->setLHKaon(LH_K);
  allResponse->setLHProton(LH_p);


  if (fVb>2) cout <<"--------------------------------------"<<endl<<"*** OVERALL RESPONSE ***"<<endl<<"--------------------------------------" <<endl;
  if (fVb>2) allResponse->print(cout);
  if (fVb>2) cout <<"--------------------------------------"<<endl;

  return allResponse;
}

void PndFastSim::UpdateGammaHit ( PndFsmTrack *  t )

private

Definition at line 1470 of file PndFastSim.cxx.

References fabs(), PndFsmTrack::p4(), PndFsmTrack::setStopVtx(), PndFsmTrack::stopVtx(), x, y, and z.

Referenced by cutAndSmear().

{
  TVector3 hitpos=t->stopVtx();
  double z=hitpos.z();
  if(z==0.)
  { //barrel - TODO convention to set z=0 initially. 
    if(fabs(t->p4().Perp()) < 1e-9) return;
    double perpscale = hitpos.Perp()/t->p4().Perp();
    double x = t->p4().Px()*perpscale;
    double y = t->p4().Py()*perpscale;
    z = t->p4().Pz()*perpscale;
    hitpos.SetXYZ(x,y,z);
  } else 
  { // z-fixed disks
    double zscale = z/t->p4().Pz();
    double x = t->p4().Px()*zscale;
    double y = t->p4().Py()*zscale;
    hitpos.SetXYZ(x,y,z);
  }
  t->setStopVtx(hitpos);

}

Member Data Documentation

int PndFastSim::evtcnt

private

Definition at line 110 of file PndFastSim.h.

Referenced by Exec(), Finish(), and Init().

std::string PndFastSim::fAddedDets

private

Definition at line 139 of file PndFastSim.h.

Referenced by AddDetector(), and PndFastSim().

bool PndFastSim::fApplyFilter

private

Definition at line 124 of file PndFastSim.h.

Referenced by Exec(), Finish(), PndFastSim(), and SetInvMassFilter().

TF1* PndFastSim::fBremsEnergy

private

Definition at line 112 of file PndFastSim.h.

Referenced by Exec(), and Init().

bool PndFastSim::fChargeConj

private

Definition at line 133 of file PndFastSim.h.

Referenced by acceptFilters(), PndFastSim(), and SetInvMassFilter().

int PndFastSim::fCombIndex[5]

private

Definition at line 131 of file PndFastSim.h.

Referenced by acceptFilters(), PndFastSim(), and SetInvMassFilter().

int PndFastSim::fCombMult

private

Definition at line 132 of file PndFastSim.h.

Referenced by acceptFilters(), PndFastSim(), and SetInvMassFilter().

TDatabasePDG* PndFastSim::fdbPdg

private

Definition at line 142 of file PndFastSim.h.

Referenced by Exec(), and PndFastSim().

PndFsmDetFactory* PndFastSim::fDetFac

private

Definition at line 138 of file PndFastSim.h.

Referenced by AddDetector(), PndFastSim(), and ~PndFastSim().

FsmAbsDetList PndFastSim::fDetList

private

Definition at line 140 of file PndFastSim.h.

Referenced by AddDetector(), Init(), Register(), and smearTrack().

bool PndFastSim::fElectronBrems

private

Definition at line 115 of file PndFastSim.h.

Referenced by EnableElectronBremsstrahlung(), Exec(), and PndFastSim().

TMatrixD PndFastSim::fEta

staticprivate

Definition at line 152 of file PndFastSim.h.

Referenced by cutAndSmear(), and Init().

TClonesArray* PndFastSim::fEventInfo

private

PndPidProbability TCA's for individual detectors.

Definition at line 106 of file PndFastSim.h.

Referenced by Exec(), Register(), and ~PndFastSim().

bool PndFastSim::fGenSplitOffs

private

Definition at line 113 of file PndFastSim.h.

Referenced by EnableSplitoffs(), Exec(), and PndFastSim().

TString PndFastSim::fInvMassFilter

private

Definition at line 127 of file PndFastSim.h.

Referenced by Finish(), PndFastSim(), and SetInvMassFilter().

double PndFastSim::fInvMassMax

private

Definition at line 129 of file PndFastSim.h.

Referenced by acceptFilters(), Finish(), PndFastSim(), and SetInvMassFilter().

double PndFastSim::fInvMassMin

private

Definition at line 128 of file PndFastSim.h.

Referenced by acceptFilters(), Finish(), PndFastSim(), and SetInvMassFilter().

int PndFastSim::fInvMassMult

private

Definition at line 130 of file PndFastSim.h.

Referenced by acceptFilters(), Finish(), PndFastSim(), and SetInvMassFilter().

TClonesArray* PndFastSim::fMcCandidates

private

Output array of Candidates

Definition at line 97 of file PndFastSim.h.

Referenced by Exec(), Register(), and ~PndFastSim().

bool PndFastSim::fMergeNeutralClusters

private

Definition at line 114 of file PndFastSim.h.

Referenced by Exec(), MergeNeutralClusters(), and PndFastSim().

double PndFastSim::fMergeProbPar

private

Definition at line 116 of file PndFastSim.h.

Referenced by Exec(), MergeNeutralClusters(), and PndFastSim().

TClonesArray* PndFastSim::fMicroCandidates

private

Definition at line 100 of file PndFastSim.h.

int PndFastSim::fMultMax[6]

private

Definition at line 126 of file PndFastSim.h.

Referenced by acceptFilters(), Finish(), PndFastSim(), and SetMultFilter().

int PndFastSim::fMultMin[6]

private

Definition at line 125 of file PndFastSim.h.

Referenced by acceptFilters(), Finish(), PndFastSim(), and SetMultFilter().

int PndFastSim::fNAccept

private

Definition at line 134 of file PndFastSim.h.

Referenced by Exec(), Finish(), and PndFastSim().

bool PndFastSim::fPersist

private

Definition at line 136 of file PndFastSim.h.

Referenced by PndFastSim(), and Register().

std::map<TString,TClonesArray*> PndFastSim::fPidArrayList

private

PndPidProbability TCA for neutral particles.

Definition at line 104 of file PndFastSim.h.

Referenced by Exec(), Register(), and smearTrack().

TClonesArray* PndFastSim::fPidChargedCand

private

Definition at line 98 of file PndFastSim.h.

Referenced by Exec(), Register(), and ~PndFastSim().

TClonesArray* PndFastSim::fPidChargedProb

private

Definition at line 101 of file PndFastSim.h.

Referenced by Exec(), Register(), and ~PndFastSim().

TClonesArray* PndFastSim::fPidNeutralCand

private

Definition at line 99 of file PndFastSim.h.

Referenced by Exec(), Register(), and ~PndFastSim().

TClonesArray* PndFastSim::fPidNeutralProb

private

PndPidProbability TCA for charged particles.

Definition at line 102 of file PndFastSim.h.

Referenced by Exec(), Register(), and ~PndFastSim().

bool PndFastSim::fPropagate

private

Definition at line 117 of file PndFastSim.h.

Referenced by cutAndSmear(), EnablePropagation(), Exec(), and PndFastSim().

TRandom3* PndFastSim::fRand

private

Definition at line 108 of file PndFastSim.h.

Referenced by cutAndSmear(), Exec(), PndFastSim(), SetSeed(), smearEnergy(), smearMomentum(), smearPhi(), smearTheta(), smearVertex(), and ~PndFastSim().

TMatrixD PndFastSim::fRho

staticprivate

Definition at line 151 of file PndFastSim.h.

Referenced by cutAndSmear(), and Init().

TF1* PndFastSim::fspo[5][4]

private

Definition at line 111 of file PndFastSim.h.

Referenced by EnableSplitoffs(), and Exec().

double PndFastSim::fTolerance

private

Definition at line 121 of file PndFastSim.h.

Referenced by cutAndSmear(), and EnablePropagation().

bool PndFastSim::fToStartVtx

private

Definition at line 118 of file PndFastSim.h.

Referenced by cutAndSmear(), EnablePropagation(), and PndFastSim().

bool PndFastSim::fUseCovMatrix

private

Definition at line 119 of file PndFastSim.h.

Referenced by cutAndSmear(), EnablePropagation(), and PndFastSim().

bool PndFastSim::fUseFlatCovMatrix

private

Definition at line 120 of file PndFastSim.h.

Referenced by cutAndSmear(), Exec(), PndFastSim(), and SetUseFlatCov().

int PndFastSim::fVb

private

Definition at line 109 of file PndFastSim.h.

Referenced by acceptFilters(), AddDetector(), EnableSplitoffs(), Exec(), Init(), PndFastSim(), SetVerbosity(), and sumResponse().

---

The documentation for this class was generated from the following files:

• PndFastSim.h
• PndFastSim.cxx