//
// Default constructor
//
+ for (Int_t i = 0; i < 4; i++) fPint[i] = 0.;
}
//______________________________________________________________________________
fUserScore(new TObjArray(100))
{
// create geometry interface
+ for (Int_t i = 0; i < 4; i++) fPint[i] = 0.;
+
if (fVerbosityLevel >=3)
cout << "<== TFluka::TFluka(" << title << ") constructor called." << endl;
SetCoreInputFileName();
cout << "<== TFluka::~TFluka() destructor called." << endl;
if (fMaterials) delete [] fMaterials;
- delete fGeom;
- delete fMCGeo;
+// delete fGeom;
+// delete fMCGeo;
if (fUserConfig) {
fUserConfig->Delete();
//
// Run steering
//
-
+
if (fVerbosityLevel >=3)
cout << "==> TFluka::ProcessRun(" << nevent << ") called."
<< endl;
// In this case, WMAT in output is changed to relative
// weigths.
//
+ printf("Mixture %5d %10s %5d \n", kmat, name, nlmat);
+
Int_t i,j;
if (nlmat < 0) {
nlmat = - nlmat;
delete [] wmatnew;
return;
}
- gGeoManager->Mixture(name, a, z, dens, nlmat, wmat, kmat);
+ printf("Mixture (2) %5d %10s %5d \n", kmat, name, nlmat);
+ gGeoManager->Mixture(name, a, z, dens, nlmat, wmat, kmat);
}
//______________________________________________________________________________
//
//
// Create object holding Cerenkov properties
-//
+//
+
TFlukaCerenkov* cerenkovProperties = new TFlukaCerenkov(npckov, ppckov, absco, effic, rindex);
//
// Pass object to medium
//______________________________________________________________________________
-void TFluka::SetCerenkov(Int_t /*itmed*/, Int_t /*npckov*/, Double_t * /*ppckov*/,
- Double_t * /*absco*/, Double_t * /*effic*/, Double_t * /*rindex*/) {
+void TFluka::SetCerenkov(Int_t itmed, Int_t npckov, Double_t *ppckov,
+ Double_t *absco, Double_t *effic, Double_t *rindex) {
+//
+// Set Cerenkov properties for medium itmed
+//
+// npckov: number of sampling points
+// ppckov: energy values
+// absco: absorption length
+// effic: quantum efficiency
+// rindex: refraction index
+//
+
//
-// Double_t version not implemented
+// Double_t version
+ Float_t* fppckov = CreateFloatArray(ppckov, npckov);
+ Float_t* fabsco = CreateFloatArray(absco, npckov);
+ Float_t* feffic = CreateFloatArray(effic, npckov);
+ Float_t* frindex = CreateFloatArray(rindex, npckov);
+
+ SetCerenkov(itmed, npckov, fppckov, fabsco, feffic, frindex);
+
+ delete [] fppckov;
+ delete [] fabsco;
+ delete [] feffic;
+ delete [] frindex;
}
-void TFluka::SetCerenkov(Int_t /*itmed*/, Int_t /*npckov*/, Double_t* /*ppckov*/,
- Double_t* /*absco*/, Double_t* /*effic*/, Double_t* /*rindex*/, Double_t* /*rfl*/) {
+void TFluka::SetCerenkov(Int_t itmed, Int_t npckov, Double_t* ppckov,
+ Double_t* absco, Double_t* effic, Double_t* rindex, Double_t* rfl) {
//
-// // Double_t version not implemented
+// Set Cerenkov properties for medium itmed
+//
+// npckov: number of sampling points
+// ppckov: energy values
+// absco: absorption length
+// effic: quantum efficiency
+// rindex: refraction index
+// rfl: reflectivity for boundary to medium itmed
+//
+
+//
+// // Double_t version
+ Float_t* fppckov = CreateFloatArray(ppckov, npckov);
+ Float_t* fabsco = CreateFloatArray(absco, npckov);
+ Float_t* feffic = CreateFloatArray(effic, npckov);
+ Float_t* frindex = CreateFloatArray(rindex, npckov);
+ Float_t* frfl = CreateFloatArray(rfl, npckov);
+
+ SetCerenkov(itmed, npckov, fppckov, fabsco, feffic, frindex, frfl);
+
+ delete [] fppckov;
+ delete [] fabsco;
+ delete [] feffic;
+ delete [] frindex;
+ delete [] frfl;
}
// Euclid
//
// Get the medium number for the current fluka region
//
- return fGeom->GetMedium(); // this I need to check due to remapping !!!
+ if (gGeoManager->IsOutside()) {
+ return (-1);
+ } else {
+ return (fGeom->GetMedium()); // this I need to check due to remapping !!!
+ }
}
//____________________________________________________________________________
FlukaCallerCode_t caller = GetCaller();
FlukaProcessCode_t icode = GetIcode();
- if (caller != kEEDRAW &&
- caller != kMGResumedTrack &&
- caller != kSODRAW &&
+ if (caller != kEEDRAW &&
+ caller != kMGResumedTrack &&
+ caller != kSODRAW &&
+ caller != kUSDRAW &&
(caller != kENDRAW || (icode != kEMFSCOstopping1 && icode != kEMFSCOstopping2))) {
if (TRACKR.ptrack >= 0) {
momentum.SetPx(TRACKR.ptrack*TRACKR.cxtrck);
momentum.SetPy(p * FLKSTK.tyflk[ist]);
momentum.SetPz(p * FLKSTK.tzflk[ist]);
momentum.SetE(e);
+ } else if (caller == kUSDRAW) {
+ if (icode == kEMFSCObrems ||
+ icode == kEMFSCOmoller ||
+ icode == kEMFSCObhabha ||
+ icode == kEMFSCOcompton )
+ {
+ momentum.SetPx(fPint[0]);
+ momentum.SetPy(fPint[1]);
+ momentum.SetPz(fPint[2]);
+ momentum.SetE(fPint[3]);
+ } else if (icode == kKASKADdray ||
+ icode == kKASKADbrems ||
+ icode == kKASKADpair) {
+ momentum.SetPx(GENSTK.plr[0] * GENSTK.cxr[0]);
+ momentum.SetPy(GENSTK.plr[0] * GENSTK.cyr[0]);
+ momentum.SetPz(GENSTK.plr[0] * GENSTK.czr[0]);
+ momentum.SetE (GENSTK.tki[0] + PAPROP.am[GENSTK.kpart[0]+6]);
+ } else {
+ Double_t p = sqrt(TRACKR.etrack * TRACKR.etrack
+ - ParticleMassFPC(TRACKR.jtrack)
+ * ParticleMassFPC(TRACKR.jtrack));
+ momentum.SetPx(p*TRACKR.cxtrck);
+ momentum.SetPy(p*TRACKR.cytrck);
+ momentum.SetPz(p*TRACKR.cztrck);
+ momentum.SetE(TRACKR.etrack);
+ }
}
else
Warning("TrackMomentum","momentum not available");
if (caller != kEEDRAW &&
caller != kMGResumedTrack &&
caller != kSODRAW &&
+ caller != kUSDRAW &&
(caller != kENDRAW || (icode != kEMFSCOstopping1 && icode != kEMFSCOstopping2))) {
if (TRACKR.ptrack >= 0) {
px = TRACKR.ptrack*TRACKR.cxtrck;
px = p * FLKSTK.txflk[ist];
py = p * FLKSTK.tyflk[ist];
pz = p * FLKSTK.tzflk[ist];
+ } else if (caller == kUSDRAW) {
+ if (icode == kEMFSCObrems ||
+ icode == kEMFSCOmoller ||
+ icode == kEMFSCObhabha ||
+ icode == kEMFSCOcompton )
+ {
+ px = fPint[0];
+ py = fPint[1];
+ pz = fPint[2];
+ e = fPint[3];
+ } else if (icode == kKASKADdray ||
+ icode == kKASKADbrems ||
+ icode == kKASKADpair) {
+ px = GENSTK.plr[0] * GENSTK.cxr[0];
+ py = GENSTK.plr[0] * GENSTK.cyr[0];
+ pz = GENSTK.plr[0] * GENSTK.czr[0];
+ e = GENSTK.tki[0] + PAPROP.am[GENSTK.kpart[0]+6];
+ } else {
+ Double_t p = sqrt(TRACKR.etrack * TRACKR.etrack - ParticleMassFPC(TRACKR.jtrack) * ParticleMassFPC(TRACKR.jtrack));
+ px = p*TRACKR.cxtrck;
+ py = p*TRACKR.cytrck;
+ pz = p*TRACKR.cztrck;
+ e = TRACKR.etrack;
+ }
}
else
Warning("TrackMomentum","momentum not available");
return TRACKR.cmtrck;
else if (caller == kMGResumedTrack)
return TRACKR.spausr[8];
+ else if (caller == kSODRAW)
+ return 0.0;
else {
- Warning("TrackLength", "track length not available");
+ Warning("TrackLength", "track length not available for caller %5d \n", caller);
return 0.0;
}
}
if (caller != kEEDRAW && caller != kSODRAW)
return PAPROP.am[CorrectFlukaId()+6];
else if (caller == kSODRAW) {
- Int_t ifl = PDGFromId(FLKSTK.iloflk[FLKSTK.npflka]);
+ Int_t ifl = FLKSTK.iloflk[FLKSTK.npflka];
return PAPROP.am[ifl + 6];
}
else
Double_t TFluka::Etot() const
{
// TRACKR.etrack = total energy of the particle
- FlukaCallerCode_t caller = GetCaller();
- if (caller != kEEDRAW && caller != kSODRAW)
- return TRACKR.etrack;
+ FlukaCallerCode_t caller = GetCaller();
+ FlukaProcessCode_t icode = GetIcode();
+ if (caller != kEEDRAW && caller != kSODRAW && caller != kUSDRAW)
+ {
+ return TRACKR.etrack;
+ } else if (caller == kUSDRAW) {
+ if (icode == kEMFSCObrems ||
+ icode == kEMFSCOmoller ||
+ icode == kEMFSCObhabha ||
+ icode == kEMFSCOcompton ) {
+ return fPint[3];
+ }
+ else if (icode == kKASKADdray ||
+ icode == kKASKADbrems ||
+ icode == kKASKADpair) {
+ return (GENSTK.tki[0] + PAPROP.am[GENSTK.kpart[0]+6]);
+ }
+ }
else if (caller == kSODRAW) {
Int_t ist = FLKSTK.npflka;
Double_t p = FLKSTK.pmoflk[ist];
Double_t e = TMath::Sqrt(p * p + m * m);
return e;
}
- else
- return -1000.0;
+
+ return -1000.0;
}
//
//
// Return processes active in the current step
//
- FlukaProcessCode_t icode = GetIcode();
+ FlukaProcessCode_t icode = GetIcode();
+ FlukaCallerCode_t caller = GetCaller();
+
proc.Set(1);
TMCProcess iproc;
- switch (icode) {
- case kKASKADtimekill:
- case kEMFSCOtimekill:
- case kKASNEUtimekill:
- case kKASHEAtimekill:
- case kKASOPHtimekill:
- iproc = kPTOFlimit;
- break;
- case kKASKADstopping:
- case kKASKADescape:
- case kEMFSCOstopping1:
- case kEMFSCOstopping2:
- case kEMFSCOescape:
- case kKASNEUstopping:
- case kKASNEUescape:
- case kKASHEAescape:
- case kKASOPHescape:
- iproc = kPStop;
- break;
- case kKASOPHabsorption:
- iproc = kPLightAbsorption;
- break;
- case kKASOPHrefraction:
- iproc = kPLightRefraction;
- case kEMFSCOlocaldep :
- iproc = kPPhotoelectric;
- break;
- default:
- iproc = ProdProcess(0);
+ if (caller == kBXEntering || caller == kBXExiting || caller == kEEDRAW || caller == kSODRAW) {
+ iproc = kPTransportation;
}
+ else if (caller == kUSTCKV) {
+ iproc = kPCerenkov;
+ } else {
+ switch (icode) {
+ case kEMFSCO:
+ if (Edep() > 0.) {
+ iproc = kPEnergyLoss;
+ } else {
+ iproc = kPTransportation;
+ }
+ break;
+ case kKASKAD:
+ if (Edep() > 0.) {
+ iproc = kPEnergyLoss;
+ } else {
+ iproc = kPTransportation;
+ }
+ break;
+ case kKASHEA:
+ case kKASNEU:
+ case kKASOPH:
+ case kKASKADescape:
+ case kEMFSCOescape:
+ case kKASNEUescape:
+ case kKASHEAescape:
+ case kKASOPHescape:
+ iproc = kPTransportation;
+ break;
+ case kKASKADtimekill:
+ case kEMFSCOtimekill:
+ case kKASNEUtimekill:
+ case kKASHEAtimekill:
+ case kKASOPHtimekill:
+ iproc = kPTOFlimit;
+ break;
+ case kKASKADstopping:
+ case kEMFSCOstopping1:
+ case kEMFSCOstopping2:
+ case kKASNEUstopping:
+ iproc = kPStop;
+ break;
+ case kKASOPHabsorption:
+ iproc = kPLightAbsorption;
+ break;
+ case kKASOPHrefraction:
+ iproc = kPLightRefraction;
+ break;
+ case kEMFSCOlocaldep :
+ iproc = kPPhotoelectric;
+ break;
+ default:
+ iproc = ProdProcess(0);
+ }
+ }
+
proc[0] = iproc;
return 1;
}
return fMCGeo->VolName(id);
}
+Int_t TFluka::MediumId(const Text_t* mediumName) const
+{
+ //
+ // Return the unique medium id for medium with name mediumName
+ TList *medlist = gGeoManager->GetListOfMedia();
+ TGeoMedium* med = (TGeoMedium*) medlist->FindObject(mediumName);
+ if (med) {
+ return (med->GetId());
+ } else {
+ return (-1);
+ }
+}
+
//______________________________________________________________________________
Int_t TFluka::VolId(const Text_t* volName) const
{
//
// Return the current volume name
//
- if (gGeoManager->IsOutside()) return 0;
+ if (gGeoManager->IsOutside()) return "OutOfWorld";
return gGeoManager->GetCurrentVolume()->GetName();
}
// Reset the index
SetCurrentPrimaryElectronIndex(-1);
}
+
+//______________________________________________________________________
+Float_t* TFluka::CreateFloatArray(Double_t* array, Int_t size) const
+{
+// Converts Double_t* array to Float_t*,
+// !! The new array has to be deleted by user.
+// ---
+
+ Float_t* floatArray;
+ if (size>0) {
+ floatArray = new Float_t[size];
+ for (Int_t i=0; i<size; i++)
+ if (array[i] >= FLT_MAX )
+ floatArray[i] = FLT_MAX/100.;
+ else
+ floatArray[i] = array[i];
+ }
+ else {
+ //floatArray = 0;
+ floatArray = new Float_t[1];
+ }
+ return floatArray;
+}