Gstpar implemented.
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 8 Apr 2004 16:32:00 +0000 (16:32 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 8 Apr 2004 16:32:00 +0000 (16:32 +0000)
TFluka/TFlukaGeo.cxx
TFluka/TFlukaGeo.h

index 309b9d003ff32bafcd6b59309f28e0c16a2e9b6b..981b607d941203fcacdc423ec36d02e65c2a346b 100644 (file)
@@ -17,6 +17,8 @@
 
 #include <Riostream.h>
 
+#include "AliModule.h"
+#include "AliRun.h"
 #include "TClonesArray.h"
 #include "TFlukaGeo.h"
 #include "TCallf77.h"      //For the fortran calls
@@ -139,6 +141,27 @@ void TFluka::Init() {
     cout << "\t* InitPhysics() - Prepare input file to be called" << endl; 
     // now we have TGeo geometry created and we have to patch alice.inp
     // with the material mapping file FlukaMat.inp
+}
+
+
+//______________________________________________________________________________ 
+void TFluka::FinishGeometry() {
+//
+// Build-up table with region to medium correspondance
+//
+  if (fVerbosityLevel >=3)
+    cout << "==> TFluka::FinishGeometry() called." << endl;
+
+   printf("----FinishGeometry - nothing to do with TGeo\n");
+  
+  if (fVerbosityLevel >=3)
+    cout << "<== TFluka::FinishGeometry() called." << endl;
+} 
+
+//______________________________________________________________________________ 
+void TFluka::BuildPhysics() {
+    if (fVerbosityLevel >=3)
+       cout << "==> TFluka::BuildPhysics() called." << endl;
     InitPhysics(); // prepare input file with the current physics settings
     cout << "\t* InitPhysics() - Prepare input file was called" << endl; 
     
@@ -164,30 +187,10 @@ void TFluka::Init() {
     
     if (fVerbosityLevel >=3)
        cout << "<== TFluka::Init() called." << endl;
-}
-
-//______________________________________________________________________________ 
-void TFluka::FinishGeometry() {
-//
-// Build-up table with region to medium correspondance
-//
-  if (fVerbosityLevel >=3)
-    cout << "==> TFluka::FinishGeometry() called." << endl;
-
-   printf("----FinishGeometry - nothing to do with TGeo\n");
-  
-  if (fVerbosityLevel >=3)
-    cout << "<== TFluka::FinishGeometry() called." << endl;
-} 
-
-//______________________________________________________________________________ 
-void TFluka::BuildPhysics() {
-  if (fVerbosityLevel >=3)
-    cout << "==> TFluka::BuildPhysics() called." << endl;
-
-
-  if (fVerbosityLevel >=3)
-    cout << "<== TFluka::BuildPhysics() called." << endl;
+    
+    
+    if (fVerbosityLevel >=3)
+       cout << "<== TFluka::BuildPhysics() called." << endl;
 }  
 
 //______________________________________________________________________________ 
@@ -301,10 +304,39 @@ void TFluka::Matrix(Int_t& krot, Double_t thetaX, Double_t phiX,
 } 
 
 //______________________________________________________________________________ 
-void TFluka::Gstpar(Int_t /*itmed*/, const char */*param*/, Double_t /*parval*/) {
+void TFluka::Gstpar(Int_t itmed, const char* param, Double_t parval) {
 //
 // Is it needed with TGeo ??? - to clear-up
-   Warning("Gstpar", "Not implemented with TGeo");
+//
+    
+   printf("Gstpar called with %6d %5s %12.4e %6d\n", itmed, param, parval, fGeom->GetFlukaMaterial(itmed));
+   Bool_t process = kFALSE;
+   if (strncmp(param, "DCAY",  4) == 0 ||
+       strncmp(param, "PAIR",  4) == 0 ||
+       strncmp(param, "COMP",  4) == 0 ||
+       strncmp(param, "PHOT",  4) == 0 ||
+       strncmp(param, "PFIS",  4) == 0 ||
+       strncmp(param, "DRAY",  4) == 0 ||
+       strncmp(param, "ANNI",  4) == 0 ||
+       strncmp(param, "BREM",  4) == 0 ||
+       strncmp(param, "MUNU",  4) == 0 ||
+       strncmp(param, "CKOV",  4) == 0 ||
+       strncmp(param, "HADR",  4) == 0 ||
+       strncmp(param, "LOSS",  4) == 0 ||
+       strncmp(param, "MULS",  4) == 0 ||
+       strncmp(param, "RAYL",  4) == 0) 
+   {
+       process = kTRUE;
+   } 
+   if (process) {
+       SetProcess(param, Int_t (parval), fGeom->GetFlukaMaterial(itmed));
+   } else {
+       SetCut(param, parval, fGeom->GetFlukaMaterial(itmed));
+   }
+   
+   
+   
 }    
 
 // functions from GGEOM 
@@ -509,44 +541,58 @@ Int_t TFluka::PDGFromId(Int_t id) const
 // set methods
 //
 
+void TFluka::SetProcess(const char* flagName, Int_t flagValue, Int_t imed)
+{
+    strcpy(&fProcessFlag[fNbOfProc][0],flagName);
+    fProcessValue[fNbOfProc] = flagValue;
+    fProcessMedium[fNbOfProc] = imed;
+    fNbOfProc++;
+}
+
 //______________________________________________________________________________ 
 void TFluka::SetProcess(const char* flagName, Int_t flagValue)
 {
   Int_t i;
-  if (iNbOfProc < 100) {
-    for (i=0; i<iNbOfProc; i++) {
-      if (strcmp(&sProcessFlag[i][0],flagName) == 0) {
-        iProcessValue[iNbOfProc] = flagValue;
-       goto fin;
+  if (fNbOfProc < 100) {
+    for (i=0; i<fNbOfProc; i++) {
+      if (strcmp(&fProcessFlag[i][0],flagName) == 0) {
+        fProcessValue[fNbOfProc] = flagValue;
+       return;
       }
     }
-    strcpy(&sProcessFlag[iNbOfProc][0],flagName);
-    iProcessValue[iNbOfProc++] = flagValue;
+    strcpy(&fProcessFlag[fNbOfProc][0],flagName);
+    fProcessValue[fNbOfProc++] = flagValue;
   }
   else
     cout << "Nb of SetProcess calls exceeds 100 - ignored" << endl;
-fin:
-  iNbOfProc = iNbOfProc;
+}
+
+//______________________________________________________________________________ 
+void TFluka::SetCut(const char* cutName, Double_t cutValue, Int_t imed)
+{
+    strcpy(&fCutFlag[fNbOfCut][0],cutName);
+    fCutValue[fNbOfCut]  = cutValue;
+    fCutMedium[fNbOfCut] = imed;
+    fNbOfCut++;
 }
 
 //______________________________________________________________________________ 
 void TFluka::SetCut(const char* cutName, Double_t cutValue)
 {
   Int_t i;
-  if (iNbOfCut < 100) {
-    for (i=0; i<iNbOfCut; i++) {
-      if (strcmp(&sCutFlag[i][0],cutName) == 0) {
-        fCutValue[iNbOfCut] = cutValue;
-       goto fin;
+  if (fNbOfCut < 100) {
+    for (i=0; i<fNbOfCut; i++) {
+      if (strcmp(&fCutFlag[i][0],cutName) == 0) {
+        fCutValue[fNbOfCut] = cutValue;
+       return;
       }
     }
-    strcpy(&sCutFlag[iNbOfCut][0],cutName);
-    fCutValue[iNbOfCut++] = cutValue;
+    strcpy(&fCutFlag[fNbOfCut][0],cutName);
+    fCutMedium[fNbOfCut] = -1;
+    fCutValue[fNbOfCut++] = cutValue;
   }
   else
     cout << "Nb of SetCut calls exceeds 100 - ignored" << endl;
-fin:
-  iNbOfCut = iNbOfCut;
 }
 
 //______________________________________________________________________________ 
@@ -562,7 +608,7 @@ void TFluka::InitPhysics()
   Int_t i, j, k;
   Double_t fCut;
 
-  FILE *pAliceCoreInp, *pAliceFlukaMat, *pAliceInp;
+  FILE *pAliceCoreInp, *pAliceFlukaMat, *pAliceInp, *pGaliceCuts;
 
   Double_t zero  = 0.0;
   Double_t one   = 1.0;
@@ -572,13 +618,22 @@ void TFluka::InitPhysics()
   Float_t fLastMaterial = fGeom->GetLastMaterialIndex();
   printf("   last FLUKA material is %g\n", fLastMaterial);
 
+  // Prepare  Cerenkov
+  TList *matList = gGeoManager->GetListOfMaterials();
+  Int_t nmaterial =  matList->GetSize();
+  fMaterials = new Int_t[nmaterial];
+             
+             
+
 // construct file names
 
   TString sAliceCoreInp = getenv("ALICE_ROOT");
+  TString sGaliceCuts = sAliceCoreInp;
   sAliceCoreInp +="/TFluka/input/";
   TString sAliceTmp = "flukaMat.inp";
   TString sAliceInp = GetInputFileName();
   sAliceCoreInp += GetCoreInputFileName();
+  sGaliceCuts +="/data/galice.cuts";
 
 // open files 
 
@@ -595,6 +650,11 @@ void TFluka::InitPhysics()
       exit(1);
   }
 
+  if ((pGaliceCuts = fopen(sGaliceCuts.Data(),"r")) == NULL) {
+    printf("\nCannot open file %s\n",sGaliceCuts.Data());
+    exit(1);
+  }
+
 // copy core input file 
   Char_t sLine[255];
   Float_t fEventsPerRun;
@@ -642,8 +702,17 @@ fin:
   fprintf(pAliceInp,"*----------------------------------------------------------------------------- \n");
   fprintf(pAliceInp,"*----- The following data are generated from SetProcess and SetCut calls ----- \n");
   fprintf(pAliceInp,"*----------------------------------------------------------------------------- \n");
-  for (i=0; i<iNbOfProc; i++) {
 
+  for (i = 0; i < fNbOfProc; i++) {
+      Float_t matMin = three;
+      Float_t matMax = fLastMaterial;
+      Bool_t  global = kTRUE;
+      if (fProcessMedium[i] != -1) {
+         matMin = Float_t(fProcessMedium[i]);
+         matMax = matMin;
+         global = kFALSE;
+      }
+      
     // annihilation
     // G3 default value: 1
     // G4 processes: G4eplusAnnihilation/G4IeplusAnnihilation
@@ -653,22 +722,22 @@ fin:
     // flag = 1 annihilation, decays processed
     // flag = 2 annihilation, no decay product stored
     // gMC ->SetProcess("ANNI",1); // EMFCUT   -1.   0.  0. 3. lastmat 0. ANNH-THR
-      if (strncmp(&sProcessFlag[i][0],"ANNI",4) == 0) {
-         if (iProcessValue[i] == 1 || iProcessValue[i] == 2) {
+      if (strncmp(&fProcessFlag[i][0],"ANNI",4) == 0) {
+         if (fProcessValue[i] == 1 || fProcessValue[i] == 2) {
              fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for e+ annihilation - resets to default=0.\n");
              fprintf(pAliceInp,"*Generated from call: SetProcess('ANNI',1) or SetProcess('ANNI',2)\n");
              // -one = kinetic energy threshold (GeV) for e+ annihilation (resets to default=0)
              // zero = not used
              // zero = not used
-             // three = lower bound of the material indices in which the respective thresholds apply
-             // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
              // one = step length in assigning indices
              // "ANNH-THR"; 
-             fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fANNH-THR\n",-one,zero,zero,three,fLastMaterial,one);
+             fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fANNH-THR\n",-one,zero,zero,matMin,matMax,one);
          }
-         else if (iProcessValue[i] == 0) {
+         else if (fProcessValue[i] == 0) {
              fprintf(pAliceInp,"*\n*No annihilation - no FLUKA card generated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('ANNI',0)\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('ANNI',0)\n");
          }
          else  {
              fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('ANNI',?) call.\n");
@@ -699,887 +768,926 @@ fin:
     // flag = 2 delta rays, no secondaries stored
     // gMC ->SetProcess("PAIR",1); // PAIRBREM  1.   0.  0. 3. lastmat
                                  // EMFCUT    0.   0. -1. 3. lastmat 0. PHOT-THR
-    else if ((strncmp(&sProcessFlag[i][0],"PAIR",4) == 0) && (iProcessValue[i] == 1 || iProcessValue[i] == 2)) {
-      for (j=0; j<iNbOfProc; j++) {
-        if ((strncmp(&sProcessFlag[j][0],"BREM",4) == 0) && (iProcessValue[j] == 1 || iProcessValue[j] == 2)) {
-          fprintf(pAliceInp,"*\n*Bremsstrahlung and pair production by muons and charged hadrons both activated\n");
-          fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',1) and SetProcess('PAIR',1)\n");
-          fprintf(pAliceInp,"*Energy threshold set by call SetCut('BCUTM',cut) or set to 0.\n");
-          fprintf(pAliceInp,"*Energy threshold set by call SetCut('PPCUTM',cut) or set to 0.\n");
-          // three = bremsstrahlung and pair production by muons and charged hadrons both are activated
-          fprintf(pAliceInp,"PAIRBREM  %10.1f",three);
-          // direct pair production by muons
-          // G4 particles: "e-", "e+"
-          // G3 default value: 0.01 GeV
-          //gMC ->SetCut("PPCUTM",cut); // total energy cut for direct pair prod. by muons
-          fCut = 0.0;
-          for (k=0; k<iNbOfCut; k++) {
-            if (strncmp(&sCutFlag[k][0],"PPCUTM",6) == 0) fCut = fCutValue[k];
-          }
-          fprintf(pAliceInp,"%10.4g",fCut);
-          // fCut; = e+, e- kinetic energy threshold (in GeV) for explicit pair production.
-          // muon and hadron bremsstrahlung
-          // G4 particles: "gamma"
-          // G3 default value: CUTGAM=0.001 GeV
-          //gMC ->SetCut("BCUTM",cut);  // cut for muon and hadron bremsstrahlung
-          fCut = 0.0;
-          for (k=0; k<iNbOfCut; k++) {
-            if (strncmp(&sCutFlag[k][0],"BCUTM",5) == 0) fCut = fCutValue[k];
-          }
-          fprintf(pAliceInp,"%10.4g%10.1f%10.1f\n",fCut,three,fLastMaterial);
-          // fCut = photon energy threshold (GeV) for explicit bremsstrahlung production
-          // three = lower bound of the material indices in which the respective thresholds apply
-          // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-         
+    else if ((strncmp(&fProcessFlag[i][0],"PAIR",4) == 0) && (fProcessValue[i] == 1 || fProcessValue[i] == 2)) {
+
+       for (j=0; j<fNbOfProc; j++) {
+           if ((strncmp(&fProcessFlag[j][0],"BREM",4) == 0) && 
+               (fProcessValue[j] == 1 || fProcessValue[j] == 2) &&
+               (fProcessMedium[j] == fProcessMedium[i])) {
+               fprintf(pAliceInp,"*\n*Bremsstrahlung and pair production by muons and charged hadrons both activated\n");
+               fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',1) and SetProcess('PAIR',1)\n");
+               fprintf(pAliceInp,"*Energy threshold set by call SetCut('BCUTM',cut) or set to 0.\n");
+               fprintf(pAliceInp,"*Energy threshold set by call SetCut('PPCUTM',cut) or set to 0.\n");
+               // three = bremsstrahlung and pair production by muons and charged hadrons both are activated
+               fprintf(pAliceInp,"PAIRBREM  %10.1f",three);
+               // direct pair production by muons
+               // G4 particles: "e-", "e+"
+               // G3 default value: 0.01 GeV
+               //gMC ->SetCut("PPCUTM",cut); // total energy cut for direct pair prod. by muons
+               fCut = 0.0;
+               for (k=0; k<fNbOfCut; k++) {
+                   if (strncmp(&fCutFlag[k][0],"PPCUTM",6) == 0 &&
+                       (fCutMedium[k] == fProcessMedium[i])) fCut = fCutValue[k];
+               }
+               fprintf(pAliceInp,"%10.4g",fCut);
+               // fCut; = e+, e- kinetic energy threshold (in GeV) for explicit pair production.
+               // muon and hadron bremsstrahlung
+               // G4 particles: "gamma"
+               // G3 default value: CUTGAM=0.001 GeV
+               //gMC ->SetCut("BCUTM",cut);  // cut for muon and hadron bremsstrahlung
+               fCut = 0.0;
+               for (k=0; k<fNbOfCut; k++) {
+                   if (strncmp(&fCutFlag[k][0],"BCUTM",5) == 0 &&
+                       (fCutMedium[k] == fProcessMedium[i])) fCut = fCutValue[k];
+               }
+               fprintf(pAliceInp,"%10.4g%10.1f%10.1f\n",fCut,matMin,matMax);
+               // fCut = photon energy threshold (GeV) for explicit bremsstrahlung production
+               // matMin = lower bound of the material indices in which the respective thresholds apply
+               // matMax = upper bound of the material indices in which the respective thresholds apply
+               
+               // for e+ and e-
+               fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for e+/e- bremsstrahlung - resets to default=0.\n");
+               fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',1);\n");
+               fCut = -1.0;
+               for (k=0; k<fNbOfCut; k++) {
+                   if (strncmp(&fCutFlag[k][0],"BCUTE",5) == 0 &&
+                       (fCutMedium[k] == fProcessMedium[i])) fCut = fCutValue[k];
+               }
+               //fCut = kinetic energy threshold (GeV) for e+/e- bremsstrahlung (resets to default=0)
+               // zero = not used
+               // zero = not used
+               // matMin = lower bound of the material indices in which the respective thresholds apply
+               // matMax = upper bound of the material indices in which the respective thresholds apply
+               // one = step length in assigning indices
+               // "ELPO-THR"; 
+               fprintf(pAliceInp,"EMFCUT    %10.4g%10.1f%10.1f%10.1f%10.1f%10.1fELPO-THR\n",fCut,zero,zero,matMin,matMax,one);
+               
           // for e+ and e-
-          fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for e+/e- bremsstrahlung - resets to default=0.\n");
-          fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',1);\n");
-          fCut = -1.0;
-          for (k=0; k<iNbOfCut; k++) {
-            if (strncmp(&sCutFlag[k][0],"BCUTE",5) == 0) fCut = fCutValue[k];
-          }
-          //fCut = kinetic energy threshold (GeV) for e+/e- bremsstrahlung (resets to default=0)
-          // zero = not used
-          // zero = not used
-          // three = lower bound of the material indices in which the respective thresholds apply
-          // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-          // one = step length in assigning indices
-          // "ELPO-THR"; 
-          fprintf(pAliceInp,"EMFCUT    %10.4g%10.1f%10.1f%10.1f%10.1f%10.1fELPO-THR\n",fCut,zero,zero,three,fLastMaterial,one);
-      
-          // for e+ and e-
-          fprintf(pAliceInp,"*\n*Pair production by electrons is activated\n");
-          fprintf(pAliceInp,"*Generated from call: SetProcess('PAIR',1);\n");
-          fCut = -1.0;
-          for (j=0; j<iNbOfCut; j++) {
-            if (strncmp(&sCutFlag[j][0],"CUTGAM",6) == 0) fCut = fCutValue[j];
-          }
-          // fCut = energy threshold (GeV) for gamma pair production (< 0.0 : resets to default, = 0.0 : ignored)
-          // three = lower bound of the material indices in which the respective thresholds apply
-          // fLastMaterial =  upper bound of the material indices in which the respective thresholds apply
-          // one = step length in assigning indices
-          fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.4g%10.1f%10.1f%10.1fPHOT-THR\n",zero,zero,fCut,three,fLastMaterial,one);
-         goto BOTH;
-        } // end of if for BREM
-      } // end of loop for BREM
-
-      // only pair production by muons and charged hadrons is activated
-      fprintf(pAliceInp,"*\n*Pair production by muons and charged hadrons is activated\n");
-      fprintf(pAliceInp,"*Generated from call: SetProcess('PAIR',1) or SetProcess('PAIR',2)\n");
-      fprintf(pAliceInp,"*Energy threshold set by call SetCut('PPCUTM',cut) or set to 0.\n");
-      // direct pair production by muons
-      // G4 particles: "e-", "e+"
-      // G3 default value: 0.01 GeV
-      //gMC ->SetCut("PPCUTM",cut); // total energy cut for direct pair prod. by muons
-      // one = pair production by muons and charged hadrons is activated
-      // zero = e+, e- kinetic energy threshold (in GeV) for explicit pair production.
-      // zero = no explicit bremsstrahlung production is simulated
-      // three = lower bound of the material indices in which the respective thresholds apply
-      // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-      fprintf(pAliceInp,"PAIRBREM  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,zero,zero,three,fLastMaterial);
+               fprintf(pAliceInp,"*\n*Pair production by electrons is activated\n");
+               fprintf(pAliceInp,"*Generated from call: SetProcess('PAIR',1);\n");
+               fCut = -1.0;
+               for (k=0; k<fNbOfCut; k++) {
+                   if (strncmp(&fCutFlag[k][0],"CUTGAM",6) == 0 &&
+                       (fCutMedium[k] == fProcessMedium[i])) fCut = fCutValue[k];
+               }
+               // fCut = energy threshold (GeV) for gamma pair production (< 0.0 : resets to default, = 0.0 : ignored)
+               // matMin = lower bound of the material indices in which the respective thresholds apply
+               // matMax =  upper bound of the material indices in which the respective thresholds apply
+               // one = step length in assigning indices
+               fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.4g%10.1f%10.1f%10.1fPHOT-THR\n",zero,zero,fCut,matMin,matMax,one);
+               goto BOTH;
+           } // end of if for BREM
+       } // end of loop for BREM
+       
+       // only pair production by muons and charged hadrons is activated
+       fprintf(pAliceInp,"*\n*Pair production by muons and charged hadrons is activated\n");
+       fprintf(pAliceInp,"*Generated from call: SetProcess('PAIR',1) or SetProcess('PAIR',2)\n");
+       fprintf(pAliceInp,"*Energy threshold set by call SetCut('PPCUTM',cut) or set to 0.\n");
+       // direct pair production by muons
+       // G4 particles: "e-", "e+"
+       // G3 default value: 0.01 GeV
+       //gMC ->SetCut("PPCUTM",cut); // total energy cut for direct pair prod. by muons
+       // one = pair production by muons and charged hadrons is activated
+       // zero = e+, e- kinetic energy threshold (in GeV) for explicit pair production.
+       // zero = no explicit bremsstrahlung production is simulated
+       // matMin = lower bound of the material indices in which the respective thresholds apply
+       // matMax = upper bound of the material indices in which the respective thresholds apply
+       fprintf(pAliceInp,"PAIRBREM  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,zero,zero,matMin,matMax);
+       
+       // for e+ and e-
+       fprintf(pAliceInp,"*\n*Pair production by electrons is activated\n");
+       fprintf(pAliceInp,"*Generated from call: SetProcess('PAIR',1) or SetProcess('PAIR',2)\n");
+       fCut = -1.0;
+       for (j=0; j<fNbOfCut; j++) {
+           if (strncmp(&fCutFlag[j][0],"CUTGAM",6) == 0 &&
+               (fCutMedium[j] == fProcessMedium[i])) fCut = fCutValue[j];
+       }
+       // zero = energy threshold (GeV) for Compton scattering (= 0.0 : ignored)
+       // zero = energy threshold (GeV) for Photoelectric (= 0.0 : ignored)
+       // fCut = energy threshold (GeV) for gamma pair production (< 0.0 : resets to default, = 0.0 : ignored)
+       // matMin = lower bound of the material indices in which the respective thresholds apply
+       // matMax = upper bound of the material indices in which the respective thresholds apply
+       // one = step length in assigning indices
+       fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.4g%10.1f%10.1f%10.1fPHOT-THR\n",zero,zero,fCut,matMin,matMax,one);
       
-      // for e+ and e-
-      fprintf(pAliceInp,"*\n*Pair production by electrons is activated\n");
-      fprintf(pAliceInp,"*Generated from call: SetProcess('PAIR',1) or SetProcess('PAIR',2)\n");
-      fCut = -1.0;
-      for (j=0; j<iNbOfCut; j++) {
-        if (strncmp(&sCutFlag[j][0],"CUTGAM",6) == 0) fCut = fCutValue[j];
-      }
-      // zero = energy threshold (GeV) for Compton scattering (= 0.0 : ignored)
-      // zero = energy threshold (GeV) for Photoelectric (= 0.0 : ignored)
-      // fCut = energy threshold (GeV) for gamma pair production (< 0.0 : resets to default, = 0.0 : ignored)
-      // three = lower bound of the material indices in which the respective thresholds apply
-      // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-      // one = step length in assigning indices
-      fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.4g%10.1f%10.1f%10.1fPHOT-THR\n",zero,zero,fCut,three,fLastMaterial,one);
-
-BOTH:
-    k = 0;
+    BOTH:
+       k = 0;
     } // end of if for PAIR
-
-
-
-    // bremsstrahlung
-    // G3 default value: 1
-    // G4 processes: G4eBremsstrahlung/G4IeBremsstrahlung,
-    //               G4MuBremsstrahlung/G4IMuBremsstrahlung,
-    //               G4LowEnergyBremstrahlung
-    // Particles: e-/e+; mu+/mu-
-    // Physics:   EM
-    // flag = 0 no bremsstrahlung
-    // flag = 1 bremsstrahlung, photon processed
-    // flag = 2 bremsstrahlung, no photon stored
-    // gMC ->SetProcess("BREM",1); // PAIRBREM  2.   0.  0. 3. lastmat
-                                 // EMFCUT   -1.   0.  0. 3. lastmat 0. ELPO-THR
-    else if (strncmp(&sProcessFlag[i][0],"BREM",4) == 0) {
-      for (j=0; j<iNbOfProc; j++) {
-        if ((strncmp(&sProcessFlag[j][0],"PAIR",4) == 0) && iProcessValue[j] == 1) goto NOBREM;
-      }
-      if (iProcessValue[i] == 1 || iProcessValue[i] == 2) { 
-        fprintf(pAliceInp,"*\n*Bremsstrahlung by muons and charged hadrons is activated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',1) or SetProcess('BREM',2)\n");
-        fprintf(pAliceInp,"*Energy threshold set by call SetCut('BCUTM',cut) or set to 0.\n");
-        // two = bremsstrahlung by muons and charged hadrons is activated
-        // zero = no meaning
-        // muon and hadron bremsstrahlung
-        // G4 particles: "gamma"
-        // G3 default value: CUTGAM=0.001 GeV
-        //gMC ->SetCut("BCUTM",cut);  // cut for muon and hadron bremsstrahlung
-        fCut = 0.0;
-        for (j=0; j<iNbOfCut; j++) {
-          if (strncmp(&sCutFlag[j][0],"BCUTM",5) == 0) fCut = fCutValue[j];
-        }
-        // fCut = photon energy threshold (GeV) for explicit bremsstrahlung production
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"PAIRBREM  %10.1f%10.1f%10.4g%10.1f%10.1f\n",two,zero,fCut,three,fLastMaterial);
-        // for e+ and e-
-        fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for e+/e- bremsstrahlung - resets to default=0.\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',1);");
-        // - one = kinetic energy threshold (GeV) for e+/e- bremsstrahlung (resets to default=0)
-        // zero = not used
-        // zero = not used
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        // one = step length in assigning indices
-        //"ELPO-THR"; 
-        fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fELPO-THR\n",-one,zero,zero,three,fLastMaterial,one);
-      }
-      else if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*No bremsstrahlung - no FLUKA card generated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',0)\n");
-      }
-      else  {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('BREM',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
-      }
-NOBREM:
-      j = 0;
-    } // end of else if (strncmp(&sProcessFlag[i][0],"BREM",4) == 0)
-
-    // Cerenkov photon generation
-    // G3 default value: 0
-    // G4 process: G4Cerenkov
-    // 
-    // Particles: charged
-    // Physics:   Optical
-    // flag = 0 no Cerenkov photon generation
-    // flag = 1 Cerenkov photon generation
-    // flag = 2 Cerenkov photon generation with primary stopped at each step
-    //xx gMC ->SetProcess("CKOV",1); // ??? Cerenkov photon generation
       
-    else if (strncmp(&sProcessFlag[i][0],"CKOV",4) == 0) {
-      if (iProcessValue[i] == 1 || iProcessValue[i] == 2) {
-    // Write comments
-         fprintf(pAliceInp, "* \n"); 
-         fprintf(pAliceInp, "*Cerenkov photon generation\n"); 
-         fprintf(pAliceInp, "*Generated from call: SetProcess('CKOV',1) or SetProcess('CKOV',2)\n"); 
-         // Get List of media
-         TList *matList = gGeoManager->GetListOfMaterials();
-         Int_t nmaterial =  matList->GetSize();
-
-         fMaterials = new Int_t[nmaterial];
-
-         // Loop over media 
-         for (Int_t i = 0; i < nmaterial; i++)
-         {
-             
-             TGeoMaterial* material = dynamic_cast<TGeoMaterial*> (matList->At(i));
-             Int_t idmat = material->GetIndex();
-             fMaterials[idmat] = i;
-             // Skip media with no Cerenkov properties
-             TFlukaCerenkov* cerenkovProp;
-             if (!(cerenkovProp = dynamic_cast<TFlukaCerenkov*>(material->GetCerenkovProperties()))) continue;
-             //
-             // This medium has Cerenkov properties 
-              //
-             //
-             // Write OPT-PROD card for each medium 
-             Float_t  emin  = cerenkovProp->GetMinimumEnergy();
-             Float_t  emax  = cerenkovProp->GetMaximumEnergy();              
-             fprintf(pAliceInp, "OPT-PROD  %10.4g%10.4g%10.4g%10.4g%10.4g%10.4gCERENKOV\n", emin, emax, 0., 
-                     Float_t(idmat), Float_t(idmat), 0.); 
-             //
-             // Write OPT-PROP card for each medium 
-             // Forcing FLUKA to call user routines (queffc.cxx, rflctv.cxx, rfrndx.cxx)
-              //
-             fprintf(pAliceInp, "OPT-PROP  %10.4g%10.4g%10.4g%10.1f%10.1f%10.1fWV-LIMIT\n",  
-                     cerenkovProp->GetMinimumWavelength(),
-                     cerenkovProp->GetMaximumWavelength(), 
-                     cerenkovProp->GetMaximumWavelength(), 
-                     Float_t(idmat), Float_t(idmat), 0.0);
-             
-             if (cerenkovProp->IsMetal()) {
-                 fprintf(pAliceInp, "OPT-PROP  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fMETAL\n",  
-                         -100., -100., -100., 
-                         Float_t(idmat), Float_t(idmat), 0.0);
-             } else {
-                 fprintf(pAliceInp, "OPT-PROP  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1f\n",  
-                         -100., -100., -100., 
-                         Float_t(idmat), Float_t(idmat), 0.0);
+      
+      
+      // bremsstrahlung
+      // G3 default value: 1
+      // G4 processes: G4eBremsstrahlung/G4IeBremsstrahlung,
+      //               G4MuBremsstrahlung/G4IMuBremsstrahlung,
+      //               G4LowEnergyBremstrahlung
+      // Particles: e-/e+; mu+/mu-
+      // Physics:   EM
+      // flag = 0 no bremsstrahlung
+      // flag = 1 bremsstrahlung, photon processed
+      // flag = 2 bremsstrahlung, no photon stored
+      // gMC ->SetProcess("BREM",1); // PAIRBREM  2.   0.  0. 3. lastmat
+      // EMFCUT   -1.   0.  0. 3. lastmat 0. ELPO-THR
+      else if (strncmp(&fProcessFlag[i][0],"BREM",4) == 0) {
+         for (j = 0; j < fNbOfProc; j++) {
+             if ((strncmp(&fProcessFlag[j][0],"PAIR",4) == 0) && 
+                 fProcessValue[j] == 1 &&
+                 (fProcessMedium[j] == fProcessMedium[i])) goto NOBREM;
+         }
+         if (fProcessValue[i] == 1 || fProcessValue[i] == 2) { 
+             fprintf(pAliceInp,"*\n*Bremsstrahlung by muons and charged hadrons is activated\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',1) or SetProcess('BREM',2)\n");
+             fprintf(pAliceInp,"*Energy threshold set by call SetCut('BCUTM',cut) or set to 0.\n");
+             // two = bremsstrahlung by muons and charged hadrons is activated
+             // zero = no meaning
+             // muon and hadron bremsstrahlung
+             // G4 particles: "gamma"
+             // G3 default value: CUTGAM=0.001 GeV
+             //gMC ->SetCut("BCUTM",cut);  // cut for muon and hadron bremsstrahlung
+             fCut = 0.0;
+             for (j=0; j<fNbOfCut; j++) {
+                 if (strncmp(&fCutFlag[j][0],"BCUTM",5) == 0 &&
+                     (fCutMedium[j] == fProcessMedium[i])) fCut = fCutValue[j];
              }
+             // fCut = photon energy threshold (GeV) for explicit bremsstrahlung production
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"PAIRBREM  %10.1f%10.1f%10.4g%10.1f%10.1f\n",two,zero,fCut,matMin,matMax);
              
-             
-             for (Int_t j = 0; j < 3; j++) {
-                 fprintf(pAliceInp, "OPT-PROP  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1f&\n",  
-                         -100., -100., -100., 
+             // for e+ and e-
+             fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for e+/e- bremsstrahlung - resets to default=0.\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',1);");
+             // - one = kinetic energy threshold (GeV) for e+/e- bremsstrahlung (resets to default=0)
+             // zero = not used
+             // zero = not used
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             // one = step length in assigning indices
+             //"ELPO-THR"; 
+             fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fELPO-THR\n",-one,zero,zero,matMin,matMax,one);
+         }
+         else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*No bremsstrahlung - no FLUKA card generated\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('BREM',0)\n");
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('BREM',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      NOBREM:
+         j = 0;
+      } // end of else if (strncmp(&fProcessFlag[i][0],"BREM",4) == 0)
+      
+      // Cerenkov photon generation
+      // G3 default value: 0
+      // G4 process: G4Cerenkov
+      // 
+      // Particles: charged
+      // Physics:   Optical
+      // flag = 0 no Cerenkov photon generation
+      // flag = 1 Cerenkov photon generation
+      // flag = 2 Cerenkov photon generation with primary stopped at each step
+      //xx gMC ->SetProcess("CKOV",1); // ??? Cerenkov photon generation
+      
+      else if (strncmp(&fProcessFlag[i][0],"CKOV",4) == 0) {
+         if ((fProcessValue[i] == 1 || fProcessValue[i] == 2) && global) {
+             // Write comments
+             fprintf(pAliceInp, "* \n"); 
+             fprintf(pAliceInp, "*Cerenkov photon generation\n"); 
+             fprintf(pAliceInp, "*Generated from call: SetProcess('CKOV',1) or SetProcess('CKOV',2)\n"); 
+             // Loop over media 
+             for (Int_t im = 0; im < nmaterial; im++)
+             {
+                 TGeoMaterial* material = dynamic_cast<TGeoMaterial*> (matList->At(im));
+                 Int_t idmat = material->GetIndex();
+
+                 if (!global && idmat != fProcessMedium[i]) continue;
+                 
+                 fMaterials[idmat] = im;
+                 // Skip media with no Cerenkov properties
+                 TFlukaCerenkov* cerenkovProp;
+                 if (!(cerenkovProp = dynamic_cast<TFlukaCerenkov*>(material->GetCerenkovProperties()))) continue;
+                 //
+                 // This medium has Cerenkov properties 
+                 //
+                 //
+                 // Write OPT-PROD card for each medium 
+                 Float_t  emin  = cerenkovProp->GetMinimumEnergy();
+                 Float_t  emax  = cerenkovProp->GetMaximumEnergy();          
+                 fprintf(pAliceInp, "OPT-PROD  %10.4g%10.4g%10.4g%10.4g%10.4g%10.4gCERENKOV\n", emin, emax, 0., 
+                         Float_t(idmat), Float_t(idmat), 0.); 
+                 //
+                 // Write OPT-PROP card for each medium 
+                 // Forcing FLUKA to call user routines (queffc.cxx, rflctv.cxx, rfrndx.cxx)
+                 //
+                 fprintf(pAliceInp, "OPT-PROP  %10.4g%10.4g%10.4g%10.1f%10.1f%10.1fWV-LIMIT\n",  
+                         cerenkovProp->GetMinimumWavelength(),
+                         cerenkovProp->GetMaximumWavelength(), 
+                         cerenkovProp->GetMaximumWavelength(), 
                          Float_t(idmat), Float_t(idmat), 0.0);
+                 
+                 if (cerenkovProp->IsMetal()) {
+                     fprintf(pAliceInp, "OPT-PROP  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fMETAL\n",  
+                             -100., -100., -100., 
+                             Float_t(idmat), Float_t(idmat), 0.0);
+                 } else {
+                     fprintf(pAliceInp, "OPT-PROP  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1f\n",  
+                             -100., -100., -100., 
+                             Float_t(idmat), Float_t(idmat), 0.0);
+                 }
+                 
+                 
+                 for (Int_t j = 0; j < 3; j++) {
+                     fprintf(pAliceInp, "OPT-PROP  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1f&\n",  
+                             -100., -100., -100., 
+                             Float_t(idmat), Float_t(idmat), 0.0);
+                 }
+                 // Photon detection efficiency user defined
+                 
+                 if (cerenkovProp->IsSensitive())
+                     fprintf(pAliceInp, "OPT-PROP  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fSENSITIV\n",  
+                             -100., -100., -100., 
+                             Float_t(idmat), Float_t(idmat), 0.0);
+                 
+             } // materials
+         } else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*No Cerenkov photon generation\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('CKOV',0)\n");
+             // zero = not used
+             // zero = not used
+             // zero = not used
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             // one = step length in assigning indices
+             //"CERE-OFF"; 
+             fprintf(pAliceInp,"OPT-PROD  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fCERE-OFF\n",zero,zero,zero,matMin,matMax,one);
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('CKOV',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // end of else if (strncmp(&fProcessFlag[i][0],"CKOV",4) == 0)
+      
+      // Compton scattering
+      // G3 default value: 1
+      // G4 processes: G4ComptonScattering,
+      //               G4LowEnergyCompton,
+      //               G4PolarizedComptonScattering
+      // Particles: gamma
+      // Physics:   EM
+      // flag = 0 no Compton scattering
+      // flag = 1 Compton scattering, electron processed
+      // flag = 2 Compton scattering, no electron stored
+      // gMC ->SetProcess("COMP",1); // EMFCUT   -1.   0.  0. 3. lastmat 0. PHOT-THR
+      else if (strncmp(&fProcessFlag[i][0],"COMP",4) == 0) {
+         if (fProcessValue[i] == 1 || fProcessValue[i] == 2) { 
+             fprintf(pAliceInp,"*\n*Energy threshold (GeV) for Compton scattering - resets to default=0.\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('COMP',1);\n");
+             // - one = energy threshold (GeV) for Compton scattering - resets to default=0.
+             // zero = not used
+             // zero = not used
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             // one = step length in assigning indices
+             //"PHOT-THR"; 
+             fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fPHOT-THR\n",-one,zero,zero,matMin,matMax,one);
+         }
+         else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*No Compton scattering - no FLUKA card generated\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('COMP',0)\n");
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('COMP',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // end of else if (strncmp(&fProcessFlag[i][0],"COMP",4) == 0)
+      
+      // decay
+      // G3 default value: 1
+      // G4 process: G4Decay
+      // 
+      // Particles: all which decay is applicable for
+      // Physics:   General
+      // flag = 0 no decays
+      // flag = 1 decays, secondaries processed
+      // flag = 2 decays, no secondaries stored
+      //gMC ->SetProcess("DCAY",1); // not available
+      else if ((strncmp(&fProcessFlag[i][0],"DCAY",4) == 0) && fProcessValue[i] == 1) 
+         cout << "SetProcess for flag=" << &fProcessFlag[i][0] << " value=" << fProcessValue[i] << " not avaliable!" << endl;
+      
+      // delta-ray
+      // G3 default value: 2
+      // !! G4 treats delta rays in different way
+      // G4 processes: G4eIonisation/G4IeIonization,
+      //               G4MuIonisation/G4IMuIonization,
+      //               G4hIonisation/G4IhIonisation
+      // Particles: charged
+      // Physics:   EM
+      // flag = 0 no energy loss
+      // flag = 1 restricted energy loss fluctuations
+      // flag = 2 complete energy loss fluctuations
+      // flag = 3 same as 1
+      // flag = 4 no energy loss fluctuations
+      // gMC ->SetProcess("DRAY",0); // DELTARAY 1.E+6 0.  0. 3. lastmat 0.
+      else if (strncmp(&fProcessFlag[i][0],"DRAY",4) == 0) {
+         if (fProcessValue[i] == 0 || fProcessValue[i] == 4) {
+             fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for delta ray production\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('DRAY',0) or SetProcess('DRAY',4)\n");
+             fprintf(pAliceInp,"*No delta ray production by muons - threshold set artificially high\n");
+             Double_t emin = 1.0e+6; // kinetic energy threshold (GeV) for delta ray production (discrete energy transfer)
+             // zero = ignored
+             // zero = ignored
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             // one = step length in assigning indices
+             fprintf(pAliceInp,"DELTARAY  %10.4g%10.1f%10.1f%10.1f%10.1f%10.1f\n",emin,zero,zero,matMin,matMax,one);
+         }
+         else if (fProcessValue[i] == 1 || fProcessValue[i] == 2 || fProcessValue[i] == 3) {
+             fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for delta ray production\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('DRAY',flag), flag=1,2,3\n");
+             fprintf(pAliceInp,"*Delta ray production by muons switched on\n");
+             fprintf(pAliceInp,"*Energy threshold set by call SetCut('DCUTM',cut) or set to 1.0e+6.\n");
+             fCut = 1.0e+6;
+             for (j = 0; j < fNbOfCut; j++) {
+                 if (strncmp(&fCutFlag[j][0],"DCUTM",5) == 0 &&
+                     fCutMedium[j] == fProcessMedium[i]) fCut = fCutValue[j];
              }
-             // Photon detection efficiency user defined
+             // fCut = kinetic energy threshold (GeV) for delta ray production (discrete energy transfer)
+             // zero = ignored
+             // zero = ignored
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax =  upper bound of the material indices in which the respective thresholds apply
+             // one = step length in assigning indices
+             fprintf(pAliceInp,"DELTARAY  %10.4g%10.1f%10.1f%10.1f%10.1f%10.1f\n",fCut,zero,zero,matMin,matMax,one);
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('DRAY',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // end of else if (strncmp(&fProcessFlag[i][0],"DRAY",4) == 0)
+      
+      // hadronic process
+      // G3 default value: 1
+      // G4 processes: all defined by TG4PhysicsConstructorHadron
+      //  
+      // Particles: hadrons
+      // Physics:   Hadron
+      // flag = 0 no multiple scattering
+      // flag = 1 hadronic interactions, secondaries processed
+      // flag = 2 hadronic interactions, no secondaries stored
+      // gMC ->SetProcess("HADR",1); // ??? hadronic process
+      //Select pure GEANH (HADR 1) or GEANH/NUCRIN (HADR 3) ?????
+      else if (strncmp(&fProcessFlag[i][0],"HADR",4) == 0) {
+         if (fProcessValue[i] == 1 || fProcessValue[i] == 2) {
+             fprintf(pAliceInp,"*\n*Hadronic interaction is ON by default in FLUKA\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+         else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*Hadronic interaction is set OFF\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('HADR',0);\n");
+             // zero = ignored
+             // three = multiple scattering for hadrons and muons is completely suppressed
+             // zero = no spin-relativistic corrections
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"MULSOPT   %10.1f%10.1f%10.1f%10.1f%10.1f\n",zero,three,zero,matMin,matMax);
+             
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('HADR',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // end of else if (strncmp(&fProcessFlag[i][0],"HADR",4) == 0)
+      
+      
+      // energy loss
+      // G3 default value: 2
+      // G4 processes: G4eIonisation/G4IeIonization,
+      //               G4MuIonisation/G4IMuIonization,
+      //               G4hIonisation/G4IhIonisation
+      // 
+      // Particles: charged
+      // Physics:   EM
+      // flag=0 no energy loss
+      // flag=1 restricted energy loss fluctuations
+      // flag=2 complete energy loss fluctuations
+      // flag=3 same as 1
+      // flag=4 no energy loss fluctuations
+      // If the value ILOSS is changed, then (in G3) cross-sections and energy
+      // loss tables must be recomputed via the command 'PHYSI'
+      // gMC ->SetProcess("LOSS",2); // ??? IONFLUCT ? energy loss
+      else if (strncmp(&fProcessFlag[i][0],"LOSS",4) == 0) {
+         if (fProcessValue[i] == 2) { // complete energy loss fluctuations
+             fprintf(pAliceInp,"*\n*Complete energy loss fluctuations do not exist in FLUKA\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('LOSS',2);\n");
+             fprintf(pAliceInp,"*flag=2=complete energy loss fluctuations\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+         else if (fProcessValue[i] == 1 || fProcessValue[i] == 3) { // restricted energy loss fluctuations
+             fprintf(pAliceInp,"*\n*Restricted energy loss fluctuations\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('LOSS',1) or SetProcess('LOSS',3)\n");
+             // one = restricted energy loss fluctuations (for hadrons and muons) switched on
+             // one = restricted energy loss fluctuations (for e+ and e-) switched on
+             // one = minimal accuracy
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"IONFLUCT  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,one,one,matMin,matMax);
+         }
+         else if (fProcessValue[i] == 4) { // no energy loss fluctuations
+             fprintf(pAliceInp,"*\n*No energy loss fluctuations\n");
+             fprintf(pAliceInp,"*\n*Generated from call: SetProcess('LOSS',4)\n");
+             // - one = restricted energy loss fluctuations (for hadrons and muons) switched off
+             // - one = restricted energy loss fluctuations (for e+ and e-) switched off
+             // one = minimal accuracy
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"IONFLUCT  %10.1f%10.1f%10.1f%10.1f%10.1f\n",-one,-one,one,matMin,matMax);
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('LOSS',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // end of else if (strncmp(&fProcessFlag[i][0],"LOSS",4) == 0)
+      
+      
+      // multiple scattering
+      // G3 default value: 1
+      // G4 process: G4MultipleScattering/G4IMultipleScattering
+      // 
+      // Particles: charged
+      // Physics:   EM
+      // flag = 0 no multiple scattering
+      // flag = 1 Moliere or Coulomb scattering
+      // flag = 2 Moliere or Coulomb scattering
+      // flag = 3 Gaussian scattering
+      // gMC ->SetProcess("MULS",1); // MULSOPT multiple scattering
+      else if (strncmp(&fProcessFlag[i][0],"MULS",4) == 0) {
+         if (fProcessValue[i] == 1 || fProcessValue[i] == 2 || fProcessValue[i] == 3) {
+             fprintf(pAliceInp,"*\n*Multiple scattering is ON by default for e+e- and for hadrons/muons\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+         else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*Multiple scattering is set OFF\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('MULS',0);\n");
+             // zero = ignored
+             // three = multiple scattering for hadrons and muons is completely suppressed
+             // three = multiple scattering for e+ and e- is completely suppressed
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"MULSOPT   %10.1f%10.1f%10.1f%10.1f%10.1f\n",zero,three,three,matMin,matMax);
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('MULS',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // end of else if (strncmp(&fProcessFlag[i][0],"MULS",4) == 0)
+      
 
-             if (cerenkovProp->IsSensitive())
-                 fprintf(pAliceInp, "OPT-PROP  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fSENSITIV\n",  
-                         -100., -100., -100., 
-                         Float_t(idmat), Float_t(idmat), 0.0);
-                 
-         } // materials
-      } else if (iProcessValue[i] == 0) {
-         fprintf(pAliceInp,"*\n*No Cerenkov photon generation\n");
-         fprintf(pAliceInp,"*Generated from call: SetProcess('CKOV',0)\n");
-         // zero = not used
-         // zero = not used
-         // zero = not used
-         // three = lower bound of the material indices in which the respective thresholds apply
-         // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-         // one = step length in assigning indices
-         //"CERE-OFF"; 
-         fprintf(pAliceInp,"OPT-PROD  %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fCERE-OFF\n",zero,zero,zero,three,fLastMaterial,one);
-      }
-      else  {
-         fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('CKOV',?) call.\n");
-         fprintf(pAliceInp,"*No FLUKA card generated\n");
-      }
-    } // end of else if (strncmp(&sProcessFlag[i][0],"CKOV",4) == 0)
+      // muon nuclear interaction
+      // G3 default value: 0
+      // G4 processes: G4MuNuclearInteraction,
+      // G4MuonMinusCaptureAtRest
+      // 
+      // Particles: mu
+      // Physics:   Not set
+      // flag = 0 no muon-nuclear interaction
+      // flag = 1 nuclear interaction, secondaries processed
+      // flag = 2 nuclear interaction, secondaries not processed
+      // gMC ->SetProcess("MUNU",1); // MUPHOTON  1.   0.  0. 3. lastmat
+      else if (strncmp(&fProcessFlag[i][0],"MUNU",4) == 0) {
+         if (fProcessValue[i] == 1) {
+             fprintf(pAliceInp,"*\n*Muon nuclear interactions with production of secondary hadrons\n");
+             fprintf(pAliceInp,"*\n*Generated from call: SetProcess('MUNU',1);\n");
+             // one = full simulation of muon nuclear interactions and production of secondary hadrons
+             // zero = ratio of longitudinal to transverse virtual photon cross-section - Default = 0.25.
+             // zero = fraction of rho-like interactions ( must be < 1) - Default = 0.75.
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"MUPHOTON  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,zero,zero,matMin,matMax);
+         }
+         else if (fProcessValue[i] == 2) {
+             fprintf(pAliceInp,"*\n*Muon nuclear interactions without production of secondary hadrons\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('MUNU',2);\n");
+             // two = full simulation of muon nuclear interactions and production of secondary hadrons
+             // zero = ratio of longitudinal to transverse virtual photon cross-section - Default = 0.25.
+             // zero = fraction of rho-like interactions ( must be < 1) - Default = 0.75.
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"MUPHOTON  %10.1f%10.1f%10.1f%10.1f%10.1f\n",two,zero,zero,matMin,matMax);
+         }
+         else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*No muon nuclear interaction - no FLUKA card generated\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('MUNU',0)\n");
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('MUNU',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // end of else if (strncmp(&fProcessFlag[i][0],"MUNU",4) == 0)
       
-    // Compton scattering
-    // G3 default value: 1
-    // G4 processes: G4ComptonScattering,
-    //               G4LowEnergyCompton,
-    //               G4PolarizedComptonScattering
-    // Particles: gamma
-    // Physics:   EM
-    // flag = 0 no Compton scattering
-    // flag = 1 Compton scattering, electron processed
-    // flag = 2 Compton scattering, no electron stored
-    // gMC ->SetProcess("COMP",1); // EMFCUT   -1.   0.  0. 3. lastmat 0. PHOT-THR
-    else if (strncmp(&sProcessFlag[i][0],"COMP",4) == 0) {
-      if (iProcessValue[i] == 1 || iProcessValue[i] == 2) { 
-        fprintf(pAliceInp,"*\n*Energy threshold (GeV) for Compton scattering - resets to default=0.\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('COMP',1);\n");
-        // - one = energy threshold (GeV) for Compton scattering - resets to default=0.
-        // zero = not used
-        // zero = not used
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        // one = step length in assigning indices
-        //"PHOT-THR"; 
-        fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fPHOT-THR\n",-one,zero,zero,three,fLastMaterial,one);
-      }
-      else if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*No Compton scattering - no FLUKA card generated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('COMP',0)\n");
-      }
-      else  {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('COMP',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+      
+      // photofission
+      // G3 default value: 0
+      // G4 process: ??
+      //
+      // Particles: gamma
+      // Physics:   ??
+      // gMC ->SetProcess("PFIS",0); // PHOTONUC -1.   0.  0. 3. lastmat 0.
+      // flag = 0 no photon fission
+      // flag = 1 photon fission, secondaries processed
+      // flag = 2 photon fission, no secondaries stored
+      else if (strncmp(&fProcessFlag[i][0],"PFIS",4) == 0) {
+         if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*No photonuclear interactions\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('PFIS',0);\n");
+             // - one = no photonuclear interactions
+             // zero = not used
+             // zero = not used
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"PHOTONUC  %10.1f%10.1f%10.1f%10.1f%10.1f\n",-one,zero,zero,matMin,matMax);
+         }
+         else if (fProcessValue[i] == 1) {
+             fprintf(pAliceInp,"*\n*Photon nuclear interactions are activated at all energies\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('PFIS',1);\n");
+             // one = photonuclear interactions are activated at all energies
+             // zero = not used
+             // zero = not used
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"PHOTONUC  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,zero,zero,matMin,matMax);
+         }
+         else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*No photofission - no FLUKA card generated\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('PFIS',0)\n");
+         }
+         else {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('PFIS',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
       }
-    } // end of else if (strncmp(&sProcessFlag[i][0],"COMP",4) == 0)
 
-    // decay
-    // G3 default value: 1
-    // G4 process: G4Decay
-    // 
-    // Particles: all which decay is applicable for
-    // Physics:   General
-    // flag = 0 no decays
-    // flag = 1 decays, secondaries processed
-    // flag = 2 decays, no secondaries stored
-    //gMC ->SetProcess("DCAY",1); // not available
-    else if ((strncmp(&sProcessFlag[i][0],"DCAY",4) == 0) && iProcessValue[i] == 1) 
-      cout << "SetProcess for flag=" << &sProcessFlag[i][0] << " value=" << iProcessValue[i] << " not avaliable!" << endl;
+      // photo electric effect
+      // G3 default value: 1
+      // G4 processes: G4PhotoElectricEffect
+      //               G4LowEnergyPhotoElectric
+      // Particles: gamma
+      // Physics:   EM
+      // flag = 0 no photo electric effect
+      // flag = 1 photo electric effect, electron processed
+      // flag = 2 photo electric effect, no electron stored
+      // gMC ->SetProcess("PHOT",1); // EMFCUT    0.  -1.  0. 3. lastmat 0. PHOT-THR
+      else if (strncmp(&fProcessFlag[i][0],"PHOT",4) == 0) {
+         if (fProcessValue[i] == 1 || fProcessValue[i] == 2) {
+             fprintf(pAliceInp,"*\n*Photo electric effect is activated\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('PHOT',1);\n");
+             // zero = ignored
+             // - one = resets to default=0.
+             // zero = ignored
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             // one = step length in assigning indices
+             //"PHOT-THR"; 
+             fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fPHOT-THR\n",zero,-one,zero,matMin,matMax,one);
+         }
+         else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*No photo electric effect - no FLUKA card generated\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('PHOT',0)\n");
+         }
+         else {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('PHOT',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // else if (strncmp(&fProcessFlag[i][0],"PHOT",4) == 0)
       
-    // delta-ray
-    // G3 default value: 2
-    // !! G4 treats delta rays in different way
-    // G4 processes: G4eIonisation/G4IeIonization,
-    //               G4MuIonisation/G4IMuIonization,
-    //               G4hIonisation/G4IhIonisation
-    // Particles: charged
-    // Physics:   EM
-    // flag = 0 no energy loss
-    // flag = 1 restricted energy loss fluctuations
-    // flag = 2 complete energy loss fluctuations
-    // flag = 3 same as 1
-    // flag = 4 no energy loss fluctuations
-    // gMC ->SetProcess("DRAY",0); // DELTARAY 1.E+6 0.  0. 3. lastmat 0.
-    else if (strncmp(&sProcessFlag[i][0],"DRAY",4) == 0) {
-      if (iProcessValue[i] == 0 || iProcessValue[i] == 4) {
-        fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for delta ray production\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('DRAY',0) or SetProcess('DRAY',4)\n");
-        fprintf(pAliceInp,"*No delta ray production by muons - threshold set artificially high\n");
-        Double_t emin = 1.0e+6; // kinetic energy threshold (GeV) for delta ray production (discrete energy transfer)
-        // zero = ignored
-        // zero = ignored
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        // one = step length in assigning indices
-        fprintf(pAliceInp,"DELTARAY  %10.4g%10.1f%10.1f%10.1f%10.1f%10.1f\n",emin,zero,zero,three,fLastMaterial,one);
-      }
-      else if (iProcessValue[i] == 1 || iProcessValue[i] == 2 || iProcessValue[i] == 3) {
-        fprintf(pAliceInp,"*\n*Kinetic energy threshold (GeV) for delta ray production\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('DRAY',flag), flag=1,2,3\n");
-        fprintf(pAliceInp,"*Delta ray production by muons switched on\n");
-        fprintf(pAliceInp,"*Energy threshold set by call SetCut('DCUTM',cut) or set to 1.0e+6.\n");
-        fCut = 1.0e+6;
-        for (j=0; j<iNbOfCut; j++) {
-          if (strncmp(&sCutFlag[j][0],"DCUTM",5) == 0) fCut = fCutValue[j];
-        }
-        // fCut = kinetic energy threshold (GeV) for delta ray production (discrete energy transfer)
-        // zero = ignored
-        // zero = ignored
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial =  upper bound of the material indices in which the respective thresholds apply
-        // one = step length in assigning indices
-        fprintf(pAliceInp,"DELTARAY  %10.4g%10.1f%10.1f%10.1f%10.1f%10.1f\n",fCut,zero,zero,three,fLastMaterial,one);
-      }
-      else  {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('DRAY',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+      
+      // Rayleigh scattering
+      // G3 default value: 0
+      // G4 process: G4OpRayleigh
+      // 
+      // Particles: optical photon
+      // Physics:   Optical
+      // flag = 0 Rayleigh scattering off
+      // flag = 1 Rayleigh scattering on
+      //xx gMC ->SetProcess("RAYL",1);
+      else if (strncmp(&fProcessFlag[i][0],"RAYL",4) == 0) {
+         if (fProcessValue[i] == 1) {
+             fprintf(pAliceInp,"*\n*Rayleigh scattering is ON by default in FLUKA\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+         else if (fProcessValue[i] == 0) {
+             fprintf(pAliceInp,"*\n*Rayleigh scattering is set OFF\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('RAYL',0);\n");
+             // - one = no Rayleigh scattering and no binding corrections for Compton
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"EMFRAY    %10.1f%10.1f%10.1f%10.1f\n",-one,three,matMin,matMax);
+         }
+         else  {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('RAYL',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // end of else if (strncmp(&fProcessFlag[i][0],"RAYL",4) == 0)
+      
+      
+      // synchrotron radiation in magnetic field
+      // G3 default value: 0
+      // G4 process: G4SynchrotronRadiation
+      // 
+      // Particles: ??
+      // Physics:   Not set
+      // flag = 0 no synchrotron radiation
+      // flag = 1 synchrotron radiation
+      //xx gMC ->SetProcess("SYNC",1); // synchrotron radiation generation
+      else if (strncmp(&fProcessFlag[i][0],"SYNC",4) == 0) {
+         fprintf(pAliceInp,"*\n*Synchrotron radiation generation is NOT implemented in FLUKA\n");
+         fprintf(pAliceInp,"*No FLUKA card generated\n");
       }
-    } // end of else if (strncmp(&sProcessFlag[i][0],"DRAY",4) == 0)
-    
-    // hadronic process
-    // G3 default value: 1
-    // G4 processes: all defined by TG4PhysicsConstructorHadron
-    //  
-    // Particles: hadrons
-    // Physics:   Hadron
-    // flag = 0 no multiple scattering
-    // flag = 1 hadronic interactions, secondaries processed
-    // flag = 2 hadronic interactions, no secondaries stored
-    // gMC ->SetProcess("HADR",1); // ??? hadronic process
-    //Select pure GEANH (HADR 1) or GEANH/NUCRIN (HADR 3) ?????
-    else if (strncmp(&sProcessFlag[i][0],"HADR",4) == 0) {
-      if (iProcessValue[i] == 1 || iProcessValue[i] == 2) {
-        fprintf(pAliceInp,"*\n*Hadronic interaction is ON by default in FLUKA\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+      
+      
+      // Automatic calculation of tracking medium parameters
+      // flag = 0 no automatic calculation
+      // flag = 1 automatic calculation
+      //xx gMC ->SetProcess("AUTO",1); // ??? automatic computation of the tracking medium parameters
+      else if (strncmp(&fProcessFlag[i][0],"AUTO",4) == 0) {
+         fprintf(pAliceInp,"*\n*Automatic calculation of tracking medium parameters is always ON in FLUKA\n");
+         fprintf(pAliceInp,"*No FLUKA card generated\n");
       }
-      else if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*Hadronic interaction is set OFF\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('HADR',0);\n");
-        // zero = ignored
-        // three = multiple scattering for hadrons and muons is completely suppressed
-        // zero = no spin-relativistic corrections
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"MULSOPT   %10.1f%10.1f%10.1f%10.1f%10.1f\n",zero,three,zero,three,fLastMaterial);
+      
+      
+      // To control energy loss fluctuation model
+      // flag = 0 Urban model
+      // flag = 1 PAI model
+      // flag = 2 PAI+ASHO model (not active at the moment)
+      //xx gMC ->SetProcess("STRA",1); // ??? energy fluctuation model
+      else if (strncmp(&fProcessFlag[i][0],"STRA",4) == 0) {
+         if (fProcessValue[i] == 0 || fProcessValue[i] == 2 || fProcessValue[i] == 3) {
+             fprintf(pAliceInp,"*\n*Ionization energy losses calculation is activated\n");
+             fprintf(pAliceInp,"*Generated from call: SetProcess('STRA',n);, n=0,1,2\n");
+             // one = restricted energy loss fluctuations (for hadrons and muons) switched on
+             // one = restricted energy loss fluctuations (for e+ and e-) switched on
+             // one = minimal accuracy
+             // matMin = lower bound of the material indices in which the respective thresholds apply
+             // matMax = upper bound of the material indices in which the respective thresholds apply
+             fprintf(pAliceInp,"IONFLUCT  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,one,one,matMin,matMax);
+         }
+         else {
+             fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('STRA',?) call.\n");
+             fprintf(pAliceInp,"*No FLUKA card generated\n");
+         }
+      } // else if (strncmp(&fProcessFlag[i][0],"STRA",4) == 0)
+      
 
-      }
-      else  {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('HADR',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
-      }
-    } // end of else if (strncmp(&sProcessFlag[i][0],"HADR",4) == 0)
 
 
-    // energy loss
-    // G3 default value: 2
-    // G4 processes: G4eIonisation/G4IeIonization,
-    //               G4MuIonisation/G4IMuIonization,
-    //               G4hIonisation/G4IhIonisation
-    // 
-    // Particles: charged
-    // Physics:   EM
-    // flag=0 no energy loss
-    // flag=1 restricted energy loss fluctuations
-    // flag=2 complete energy loss fluctuations
-    // flag=3 same as 1
-    // flag=4 no energy loss fluctuations
-    // If the value ILOSS is changed, then (in G3) cross-sections and energy
-    // loss tables must be recomputed via the command 'PHYSI'
-    // gMC ->SetProcess("LOSS",2); // ??? IONFLUCT ? energy loss
-    else if (strncmp(&sProcessFlag[i][0],"LOSS",4) == 0) {
-      if (iProcessValue[i] == 2) { // complete energy loss fluctuations
-        fprintf(pAliceInp,"*\n*Complete energy loss fluctuations do not exist in FLUKA\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('LOSS',2);\n");
-        fprintf(pAliceInp,"*flag=2=complete energy loss fluctuations\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
-      }
-      else if (iProcessValue[i] == 1 || iProcessValue[i] == 3) { // restricted energy loss fluctuations
-        fprintf(pAliceInp,"*\n*Restricted energy loss fluctuations\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('LOSS',1) or SetProcess('LOSS',3)\n");
-        // one = restricted energy loss fluctuations (for hadrons and muons) switched on
-        // one = restricted energy loss fluctuations (for e+ and e-) switched on
-        // one = minimal accuracy
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"IONFLUCT  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,one,one,three,fLastMaterial);
-      }
-      else if (iProcessValue[i] == 4) { // no energy loss fluctuations
-        fprintf(pAliceInp,"*\n*No energy loss fluctuations\n");
-        fprintf(pAliceInp,"*\n*Generated from call: SetProcess('LOSS',4)\n");
-        // - one = restricted energy loss fluctuations (for hadrons and muons) switched off
-        // - one = restricted energy loss fluctuations (for e+ and e-) switched off
-        // one = minimal accuracy
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"IONFLUCT  %10.1f%10.1f%10.1f%10.1f%10.1f\n",-one,-one,one,three,fLastMaterial);
-      }
-      else  {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('LOSS',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+      else { // processes not yet treated
+         
+         // light photon absorption (Cerenkov photons)
+         // it is turned on when Cerenkov process is turned on
+         // G3 default value: 0
+         // G4 process: G4OpAbsorption, G4OpBoundaryProcess
+         // 
+         // Particles: optical photon
+         // Physics:   Optical
+         // flag = 0 no absorption of Cerenkov photons
+         // flag = 1 absorption of Cerenkov photons
+         // gMC ->SetProcess("LABS",2); // ??? Cerenkov light absorption
+         
+
+
+         cout << "SetProcess for flag=" << &fProcessFlag[i][0] << " value=" << fProcessValue[i] << " not yet implemented!" << endl;
       }
-    } // end of else if (strncmp(&sProcessFlag[i][0],"LOSS",4) == 0)
-       
+  } //end of loop number of SetProcess calls
+
  
-    // multiple scattering
-    // G3 default value: 1
-    // G4 process: G4MultipleScattering/G4IMultipleScattering
-    // 
-    // Particles: charged
-    // Physics:   EM
-    // flag = 0 no multiple scattering
-    // flag = 1 Moliere or Coulomb scattering
-    // flag = 2 Moliere or Coulomb scattering
-    // flag = 3 Gaussian scattering
-    // gMC ->SetProcess("MULS",1); // MULSOPT multiple scattering
-    else if (strncmp(&sProcessFlag[i][0],"MULS",4) == 0) {
-      if (iProcessValue[i] == 1 || iProcessValue[i] == 2 || iProcessValue[i] == 3) {
-        fprintf(pAliceInp,"*\n*Multiple scattering is ON by default for e+e- and for hadrons/muons\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
-      }
-      else if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*Multiple scattering is set OFF\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('MULS',0);\n");
-        // zero = ignored
-        // three = multiple scattering for hadrons and muons is completely suppressed
-        // three = multiple scattering for e+ and e- is completely suppressed
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"MULSOPT   %10.1f%10.1f%10.1f%10.1f%10.1f\n",zero,three,three,three,fLastMaterial);
-      }
-      else  {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('MULS',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
-      }
-    } // end of else if (strncmp(&sProcessFlag[i][0],"MULS",4) == 0)
-
-
-    // muon nuclear interaction
-    // G3 default value: 0
-    // G4 processes: G4MuNuclearInteraction,
-    // G4MuonMinusCaptureAtRest
-    // 
-    // Particles: mu
-    // Physics:   Not set
-    // flag = 0 no muon-nuclear interaction
-    // flag = 1 nuclear interaction, secondaries processed
-    // flag = 2 nuclear interaction, secondaries not processed
-    // gMC ->SetProcess("MUNU",1); // MUPHOTON  1.   0.  0. 3. lastmat
-    else if (strncmp(&sProcessFlag[i][0],"MUNU",4) == 0) {
-      if (iProcessValue[i] == 1) {
-        fprintf(pAliceInp,"*\n*Muon nuclear interactions with production of secondary hadrons\n");
-        fprintf(pAliceInp,"*\n*Generated from call: SetProcess('MUNU',1);\n");
-        // one = full simulation of muon nuclear interactions and production of secondary hadrons
-        // zero = ratio of longitudinal to transverse virtual photon cross-section - Default = 0.25.
-        // zero = fraction of rho-like interactions ( must be < 1) - Default = 0.75.
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"MUPHOTON  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,zero,zero,three,fLastMaterial);
-      }
-      else if (iProcessValue[i] == 2) {
-        fprintf(pAliceInp,"*\n*Muon nuclear interactions without production of secondary hadrons\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('MUNU',2);\n");
-        // two = full simulation of muon nuclear interactions and production of secondary hadrons
-        // zero = ratio of longitudinal to transverse virtual photon cross-section - Default = 0.25.
-        // zero = fraction of rho-like interactions ( must be < 1) - Default = 0.75.
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"MUPHOTON  %10.1f%10.1f%10.1f%10.1f%10.1f\n",two,zero,zero,three,fLastMaterial);
-      }
-      else if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*No muon nuclear interaction - no FLUKA card generated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('MUNU',0)\n");
+// Loop over number of SetCut calls  
+  for (Int_t i = 0; i < fNbOfCut; i++) {
+      Float_t matMin = three;
+      Float_t matMax = fLastMaterial;
+      Bool_t global  = kTRUE;
+      if (fCutMedium[i] != -1) {
+         matMin = Float_t(fCutMedium[i]);
+         matMax = matMin;
+         global = kFALSE;
       }
-      else  {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('MUNU',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+    // cuts handled in SetProcess calls
+      if (strncmp(&fCutFlag[i][0],"BCUTM",5) == 0) continue;
+      else if (strncmp(&fCutFlag[i][0],"BCUTE",5) == 0) continue;
+      else if (strncmp(&fCutFlag[i][0],"DCUTM",5) == 0) continue;
+      else if (strncmp(&fCutFlag[i][0],"PPCUTM",6) == 0) continue;
+      
+      // gammas
+      // G4 particles: "gamma"
+      // G3 default value: 0.001 GeV
+      // gMC ->SetCut("CUTGAM",cut); // cut for gammas
+      
+      else if (strncmp(&fCutFlag[i][0],"CUTGAM",6) == 0 && global) {
+         fprintf(pAliceInp,"*\n*Cut for gamma\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('CUTGAM',cut);\n");
+         // -fCutValue[i];
+         // 7.0 = lower bound of the particle id-numbers to which the cut-off
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f\n",-fCutValue[i],7.0);
       }
-    } // end of else if (strncmp(&sProcessFlag[i][0],"MUNU",4) == 0)
-
 
-    // photofission
-    // G3 default value: 0
-    // G4 process: ??
-    //
-    // Particles: gamma
-    // Physics:   ??
-    // gMC ->SetProcess("PFIS",0); // PHOTONUC -1.   0.  0. 3. lastmat 0.
-    // flag = 0 no photon fission
-    // flag = 1 photon fission, secondaries processed
-    // flag = 2 photon fission, no secondaries stored
-    else if (strncmp(&sProcessFlag[i][0],"PFIS",4) == 0) {
-      if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*No photonuclear interactions\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('PFIS',0);\n");
-        // - one = no photonuclear interactions
-        // zero = not used
-        // zero = not used
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"PHOTONUC  %10.1f%10.1f%10.1f%10.1f%10.1f\n",-one,zero,zero,three,fLastMaterial);
-      }
-      else if (iProcessValue[i] == 1) {
-        fprintf(pAliceInp,"*\n*Photon nuclear interactions are activated at all energies\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('PFIS',1);\n");
-        // one = photonuclear interactions are activated at all energies
-        // zero = not used
-        // zero = not used
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"PHOTONUC  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,zero,zero,three,fLastMaterial);
+      else if (strncmp(&fCutFlag[i][0],"CUTGAM",6) == 0 && !global) {
+         fprintf(pAliceInp,"*\n*Cut specific to  material for gamma\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('CUTGAM',cut);\n");
+         // -fCutValue[i];
+         // 7.0 = lower bound of the particle id-numbers to which the cut-off
+         fprintf(pAliceInp,"EMFCUT    %10.4g%10.4g%10.1f%10.1f%10.1f%10.1f\n", 0., fCutValue[i], zero, matMin, matMax, one);
       }
-      else if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*No photofission - no FLUKA card generated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('PFIS',0)\n");
-      }
-      else {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('PFIS',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+      
+      // electrons
+      // G4 particles: "e-"
+      // ?? positrons
+      // G3 default value: 0.001 GeV
+      //gMC ->SetCut("CUTELE",cut); // cut for e+,e-
+      else if (strncmp(&fCutFlag[i][0],"CUTELE",6) == 0 && global) {
+         fprintf(pAliceInp,"*\n*Cut for electrons\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('CUTELE',cut);\n");
+         // -fCutValue[i];
+         // three = lower bound of the particle id-numbers to which the cut-off
+         // 4.0 = upper bound of the particle id-numbers to which the cut-off
+         // one = step length in assigning numbers
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f%10.1f\n",-fCutValue[i],three,4.0,one);
       }
-    }
-
-    // photo electric effect
-    // G3 default value: 1
-    // G4 processes: G4PhotoElectricEffect
-    //               G4LowEnergyPhotoElectric
-    // Particles: gamma
-    // Physics:   EM
-    // flag = 0 no photo electric effect
-    // flag = 1 photo electric effect, electron processed
-    // flag = 2 photo electric effect, no electron stored
-    // gMC ->SetProcess("PHOT",1); // EMFCUT    0.  -1.  0. 3. lastmat 0. PHOT-THR
-    else if (strncmp(&sProcessFlag[i][0],"PHOT",4) == 0) {
-      if (iProcessValue[i] == 1 || iProcessValue[i] == 2) {
-        fprintf(pAliceInp,"*\n*Photo electric effect is activated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('PHOT',1);\n");
-        // zero = ignored
-        // - one = resets to default=0.
-        // zero = ignored
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        // one = step length in assigning indices
-        //"PHOT-THR"; 
-        fprintf(pAliceInp,"EMFCUT    %10.1f%10.1f%10.1f%10.1f%10.1f%10.1fPHOT-THR\n",zero,-one,zero,three,fLastMaterial,one);
+    
+      else if (strncmp(&fCutFlag[i][0],"CUTELE",6) == 0 && !global) {
+         fprintf(pAliceInp,"*\n*Cut specific to material for electrons\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('CUTELE',cut);\n");
+         // -fCutValue[i];
+         // three = lower bound of the particle id-numbers to which the cut-off
+         // 4.0 = upper bound of the particle id-numbers to which the cut-off
+         // one = step length in assigning numbers
+         fprintf(pAliceInp,"EMFCUT    %10.4g%10.4g%10.1f%10.1f%10.1f%10.1f\n", -fCutValue[i], zero, zero, matMin, matMax, one);
       }
-      else if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*No photo electric effect - no FLUKA card generated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('PHOT',0)\n");
+      
+      // neutral hadrons
+      // G4 particles: of type "baryon", "meson", "nucleus" with zero charge
+      // G3 default value: 0.01 GeV
+      //gMC ->SetCut("CUTNEU",cut); // cut for neutral hadrons
+      else if (strncmp(&fCutFlag[i][0],"CUTNEU",6) == 0 && global) {
+         fprintf(pAliceInp,"*\n*Cut for neutral hadrons\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('CUTNEU',cut);\n");
+         
+         // 8.0 = Neutron
+         // 9.0 = Antineutron
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],8.0,9.0);
+         
+         // 12.0 = Kaon zero long
+         // 12.0 = Kaon zero long
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],12.0,12.0);
+         
+         // 17.0 = Lambda, 18.0 = Antilambda
+         // 19.0 = Kaon zero short
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],17.0,19.0);
+         
+         // 22.0 = Sigma zero, Pion zero, Kaon zero
+         // 25.0 = Antikaon zero
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],22.0,25.0);
+         
+         // 32.0 = Antisigma zero
+         // 32.0 = Antisigma zero
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],32.0,32.0);
+         
+         // 34.0 = Xi zero
+         // 35.0 = AntiXi zero
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],34.0,35.0);
+         
+         // 47.0 = D zero
+         // 48.0 = AntiD zero
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],47.0,48.0);
+         
+         // 53.0 = Xi_c zero
+         // 53.0 = Xi_c zero
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],53.0,53.0);
+         
+         // 55.0 = Xi'_c zero
+         // 56.0 = Omega_c zero
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],55.0,56.0);
+         
+         // 59.0 = AntiXi_c zero
+         // 59.0 = AntiXi_c zero
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],59.0,59.0);
+         
+         // 61.0 = AntiXi'_c zero
+         // 62.0 = AntiOmega_c zero
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],61.0,62.0);
       }
-      else {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('PHOT',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+      
+      // charged hadrons
+      // G4 particles: of type "baryon", "meson", "nucleus" with non-zero charge
+      // G3 default value: 0.01 GeV
+      //gMC ->SetCut("CUTHAD",cut); // cut for charged hadrons
+      else if (strncmp(&fCutFlag[i][0],"CUTHAD",6) == 0 && global) {
+         fprintf(pAliceInp,"*\n*Cut for charged hadrons\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('CUTHAD',cut);\n");
+         
+         // 1.0 = Proton
+         // 2.0 = Antiproton
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],1.0,2.0);
+         
+         // 13.0 = Positive Pion, Negative Pion, Positive Kaon
+         // 16.0 = Negative Kaon
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],13.0,16.0);
+         
+         // 20.0 = Negative Sigma
+         // 21.0 = Positive Sigma
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],20.0,21.0);
+         
+         // 31.0 = Antisigma minus
+         // 33.0 = Antisigma plus
+         // 2.0 = step length
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f%10.1f\n",-fCutValue[i],31.0,33.0,2.0);
+         
+         // 36.0 = Negative Xi, Positive Xi, Omega minus
+         // 39.0 = Antiomega
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],36.0,39.0);
+         
+         // 45.0 = D plus
+         // 46.0 = D minus
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],45.0,46.0);
+         
+         // 49.0 = D_s plus, D_s minus, Lambda_c plus
+         // 52.0 = Xi_c plus
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],49.0,52.0);
+         
+         // 54.0 = Xi'_c plus
+         // 60.0 = AntiXi'_c minus
+         // 6.0 = step length
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f%10.1f\n",-fCutValue[i],54.0,60.0,6.0);
+         
+         // 57.0 = Antilambda_c minus
+         // 58.0 = AntiXi_c minus
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],57.0,58.0);
       }
-    } // else if (strncmp(&sProcessFlag[i][0],"PHOT",4) == 0)
-
-
-    // Rayleigh scattering
-    // G3 default value: 0
-    // G4 process: G4OpRayleigh
-    // 
-    // Particles: optical photon
-    // Physics:   Optical
-    // flag = 0 Rayleigh scattering off
-    // flag = 1 Rayleigh scattering on
-    //xx gMC ->SetProcess("RAYL",1);
-    else if (strncmp(&sProcessFlag[i][0],"RAYL",4) == 0) {
-      if (iProcessValue[i] == 1) {
-        fprintf(pAliceInp,"*\n*Rayleigh scattering is ON by default in FLUKA\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+
+      // muons
+      // G4 particles: "mu+", "mu-"
+      // G3 default value: 0.01 GeV
+      //gMC ->SetCut("CUTMUO",cut); // cut for mu+, mu-
+      else if (strncmp(&fCutFlag[i][0],"CUTMUO",6)== 0 && global) {
+         fprintf(pAliceInp,"*\n*Cut for muons\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('CUTMUO',cut);\n");
+         // 10.0 = Muon+
+         // 11.0 = Muon-
+         fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],10.0,11.0);
       }
-      else if (iProcessValue[i] == 0) {
-        fprintf(pAliceInp,"*\n*Rayleigh scattering is set OFF\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('RAYL',0);\n");
-        // - one = no Rayleigh scattering and no binding corrections for Compton
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"EMFRAY    %10.1f%10.1f%10.1f%10.1f\n",-one,three,three,fLastMaterial);
+      
+      // delta-rays by electrons
+      // G4 particles: "e-"
+      // G3 default value: 10**4 GeV
+      // gMC ->SetCut("DCUTE",cut);  // cut for deltarays by electrons ???????????????
+      else if (strncmp(&fCutFlag[i][0],"DCUTE",5) == 0) {
+         fprintf(pAliceInp,"*\n*Cut for delta rays by electrons ????????????\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('DCUTE',cut);\n");
+         // -fCutValue[i];
+         // zero = ignored
+         // zero = ignored
+         // matMin = lower bound of the material indices in which the respective thresholds apply
+         // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
+         fprintf(pAliceInp,"EMFCUT    %10.4g%10.1f%10.1f%10.1f%10.1f\n",-fCutValue[i],zero,zero,matMin,matMax);
+         fprintf(pAliceInp,"DELTARAY  %10.4g%10.3f%10.3f%10.1f%10.1f%10.1f\n",fCutValue[i], 100., 1.03, matMin, matMax, 1.0);
+         fprintf(pAliceInp,"STEPSIZE  %10.4g%10.3f%10.3f%10.1f%10.1f\n", 0.1, 1.0, 1.00, 
+                 Float_t(gGeoManager->GetListOfUVolumes()->GetEntriesFast()-1), 1.0);
       }
-      else  {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('RAYL',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+    
+      //
+      // time of flight cut in seconds
+      // G4 particles: all
+      // G3 default value: 0.01 GeV
+      //gMC ->SetCut("TOFMAX",tofmax); // time of flight cuts in seconds
+      else if (strncmp(&fCutFlag[i][0],"TOFMAX",6) == 0) {
+         fprintf(pAliceInp,"*\n*Time of flight cuts in seconds\n");
+         fprintf(pAliceInp,"*Generated from call: SetCut('TOFMAX',tofmax);\n");
+         // zero = ignored
+         // zero = ignored
+         // -6.0 = lower bound of the particle numbers for which the transport time cut-off and/or the start signal is to be applied
+         // 64.0 = upper bound of the particle numbers for which the transport time cut-off and/or the start signal is to be applied
+         fprintf(pAliceInp,"TIME-CUT  %10.4g%10.1f%10.1f%10.1f%10.1f\n",fCutValue[i]*1.e9,zero,zero,-6.0,64.0);
       }
-    } // end of else if (strncmp(&sProcessFlag[i][0],"RAYL",4) == 0)
-
-
-    // synchrotron radiation in magnetic field
-    // G3 default value: 0
-    // G4 process: G4SynchrotronRadiation
-    // 
-    // Particles: ??
-    // Physics:   Not set
-    // flag = 0 no synchrotron radiation
-    // flag = 1 synchrotron radiation
-    //xx gMC ->SetProcess("SYNC",1); // synchrotron radiation generation
-    else if (strncmp(&sProcessFlag[i][0],"SYNC",4) == 0) {
-        fprintf(pAliceInp,"*\n*Synchrotron radiation generation is NOT implemented in FLUKA\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
-    }
-       
-
-    // Automatic calculation of tracking medium parameters
-    // flag = 0 no automatic calculation
-    // flag = 1 automatic calculation
-    //xx gMC ->SetProcess("AUTO",1); // ??? automatic computation of the tracking medium parameters
-    else if (strncmp(&sProcessFlag[i][0],"AUTO",4) == 0) {
-        fprintf(pAliceInp,"*\n*Automatic calculation of tracking medium parameters is always ON in FLUKA\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
-    }
-       
-
-    // To control energy loss fluctuation model
-    // flag = 0 Urban model
-    // flag = 1 PAI model
-    // flag = 2 PAI+ASHO model (not active at the moment)
-    //xx gMC ->SetProcess("STRA",1); // ??? energy fluctuation model
-    else if (strncmp(&sProcessFlag[i][0],"STRA",4) == 0) {
-      if (iProcessValue[i] == 0 || iProcessValue[i] == 2 || iProcessValue[i] == 3) {
-        fprintf(pAliceInp,"*\n*Ionization energy losses calculation is activated\n");
-        fprintf(pAliceInp,"*Generated from call: SetProcess('STRA',n);, n=0,1,2\n");
-        // one = restricted energy loss fluctuations (for hadrons and muons) switched on
-        // one = restricted energy loss fluctuations (for e+ and e-) switched on
-        // one = minimal accuracy
-        // three = lower bound of the material indices in which the respective thresholds apply
-        // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-        fprintf(pAliceInp,"IONFLUCT  %10.1f%10.1f%10.1f%10.1f%10.1f\n",one,one,one,three,fLastMaterial);
+      
+      else if (global){
+         cout << "SetCut for flag=" << &fCutFlag[i][0] << " value=" << fCutValue[i] << " not yet implemented!" << endl;
       }
       else {
-        fprintf(pAliceInp,"*\n*Illegal flag value in SetProcess('STRA',?) call.\n");
-        fprintf(pAliceInp,"*No FLUKA card generated\n");
+         cout << "SetCut for flag=" << &fCutFlag[i][0] << " value=" << fCutValue[i] << " (material specific) not yet implemented!" << endl;
       }
-    } // else if (strncmp(&sProcessFlag[i][0],"STRA",4) == 0)
-
-
-
-
-    else { // processes not yet treated
-
-    // light photon absorption (Cerenkov photons)
-    // it is turned on when Cerenkov process is turned on
-    // G3 default value: 0
-    // G4 process: G4OpAbsorption, G4OpBoundaryProcess
-    // 
-    // Particles: optical photon
-    // Physics:   Optical
-    // flag = 0 no absorption of Cerenkov photons
-    // flag = 1 absorption of Cerenkov photons
-    // gMC ->SetProcess("LABS",2); // ??? Cerenkov light absorption
-
-
-
-      cout << "SetProcess for flag=" << &sProcessFlag[i][0] << " value=" << iProcessValue[i] << " not yet implemented!" << endl;
-    }
-  } //end of loop number of SetProcess calls
-
-// Loop over number of SetCut calls  
-  for (Int_t i=0; i<iNbOfCut; i++) {
-
-    // cuts used in SetProcess calls
-    if (strncmp(&sCutFlag[i][0],"BCUTM",5) == 0) continue;
-    else if (strncmp(&sCutFlag[i][0],"BCUTE",5) == 0) continue;
-    else if (strncmp(&sCutFlag[i][0],"DCUTM",5) == 0) continue;
-    else if (strncmp(&sCutFlag[i][0],"PPCUTM",6) == 0) continue;
-
-    // gammas
-    // G4 particles: "gamma"
-    // G3 default value: 0.001 GeV
-    //gMC ->SetCut("CUTGAM",cut); // cut for gammas
-    else if (strncmp(&sCutFlag[i][0],"CUTGAM",6) == 0) {
-      fprintf(pAliceInp,"*\n*Cut for gamma\n");
-      fprintf(pAliceInp,"*Generated from call: SetCut('CUTGAM',cut);\n");
-      // -fCutValue[i];
-      // 7.0 = lower bound of the particle id-numbers to which the cut-off
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f\n",-fCutValue[i],7.0);
-    }
-
-    // electrons
-    // G4 particles: "e-"
-    // ?? positrons
-    // G3 default value: 0.001 GeV
-    //gMC ->SetCut("CUTELE",cut); // cut for e+,e-
-    else if (strncmp(&sCutFlag[i][0],"CUTELE",6) == 0) {
-      fprintf(pAliceInp,"*\n*Cut for electrons\n");
-      fprintf(pAliceInp,"*Generated from call: SetCut('CUTELE',cut);\n");
-      // -fCutValue[i];
-      // three = lower bound of the particle id-numbers to which the cut-off
-      // 4.0 = upper bound of the particle id-numbers to which the cut-off
-      // one = step length in assigning numbers
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f%10.1f\n",-fCutValue[i],three,4.0,one);
-    }
-
-    // neutral hadrons
-    // G4 particles: of type "baryon", "meson", "nucleus" with zero charge
-    // G3 default value: 0.01 GeV
-    //gMC ->SetCut("CUTNEU",cut); // cut for neutral hadrons
-    else if (strncmp(&sCutFlag[i][0],"CUTNEU",6) == 0) {
-      fprintf(pAliceInp,"*\n*Cut for neutral hadrons\n");
-      fprintf(pAliceInp,"*Generated from call: SetCut('CUTNEU',cut);\n");
-
-      // 8.0 = Neutron
-      // 9.0 = Antineutron
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],8.0,9.0);
-
-      // 12.0 = Kaon zero long
-      // 12.0 = Kaon zero long
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],12.0,12.0);
-
-      // 17.0 = Lambda, 18.0 = Antilambda
-      // 19.0 = Kaon zero short
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],17.0,19.0);
-
-      // 22.0 = Sigma zero, Pion zero, Kaon zero
-      // 25.0 = Antikaon zero
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],22.0,25.0);
-
-      // 32.0 = Antisigma zero
-      // 32.0 = Antisigma zero
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],32.0,32.0);
-
-      // 34.0 = Xi zero
-      // 35.0 = AntiXi zero
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],34.0,35.0);
-
-      // 47.0 = D zero
-      // 48.0 = AntiD zero
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],47.0,48.0);
-
-      // 53.0 = Xi_c zero
-      // 53.0 = Xi_c zero
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],53.0,53.0);
-
-      // 55.0 = Xi'_c zero
-      // 56.0 = Omega_c zero
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],55.0,56.0);
-
-      // 59.0 = AntiXi_c zero
-      // 59.0 = AntiXi_c zero
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],59.0,59.0);
-
-      // 61.0 = AntiXi'_c zero
-      // 62.0 = AntiOmega_c zero
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],61.0,62.0);
-    }
-
-    // charged hadrons
-    // G4 particles: of type "baryon", "meson", "nucleus" with non-zero charge
-    // G3 default value: 0.01 GeV
-    //gMC ->SetCut("CUTHAD",cut); // cut for charged hadrons
-    else if (strncmp(&sCutFlag[i][0],"CUTHAD",6) == 0) {
-      fprintf(pAliceInp,"*\n*Cut for charged hadrons\n");
-      fprintf(pAliceInp,"*Generated from call: SetCut('CUTHAD',cut);\n");
-
-      // 1.0 = Proton
-      // 2.0 = Antiproton
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],1.0,2.0);
-
-      // 13.0 = Positive Pion, Negative Pion, Positive Kaon
-      // 16.0 = Negative Kaon
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],13.0,16.0);
-
-      // 20.0 = Negative Sigma
-      // 21.0 = Positive Sigma
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],20.0,21.0);
-
-      // 31.0 = Antisigma minus
-      // 33.0 = Antisigma plus
-      // 2.0 = step length
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f%10.1f\n",-fCutValue[i],31.0,33.0,2.0);
-
-      // 36.0 = Negative Xi, Positive Xi, Omega minus
-      // 39.0 = Antiomega
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],36.0,39.0);
-
-      // 45.0 = D plus
-      // 46.0 = D minus
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],45.0,46.0);
-
-      // 49.0 = D_s plus, D_s minus, Lambda_c plus
-      // 52.0 = Xi_c plus
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],49.0,52.0);
-
-      // 54.0 = Xi'_c plus
-      // 60.0 = AntiXi'_c minus
-      // 6.0 = step length
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f%10.1f\n",-fCutValue[i],54.0,60.0,6.0);
-
-      // 57.0 = Antilambda_c minus
-      // 58.0 = AntiXi_c minus
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],57.0,58.0);
-    }
-
-    // muons
-    // G4 particles: "mu+", "mu-"
-    // G3 default value: 0.01 GeV
-    //gMC ->SetCut("CUTMUO",cut); // cut for mu+, mu-
-    else if (strncmp(&sCutFlag[i][0],"CUTMUO",6) == 0) {
-      fprintf(pAliceInp,"*\n*Cut for muons\n");
-      fprintf(pAliceInp,"*Generated from call: SetCut('CUTMUO',cut);\n");
-      // 10.0 = Muon+
-      // 11.0 = Muon-
-      fprintf(pAliceInp,"PART-THR  %10.4g%10.1f%10.1f\n",-fCutValue[i],10.0,11.0);
-    }
-
-    // delta-rays by electrons
-    // G4 particles: "e-"
-    // G3 default value: 10**4 GeV
-    // gMC ->SetCut("DCUTE",cut);  // cut for deltarays by electrons ???????????????
-    else if (strncmp(&sCutFlag[i][0],"DCUTE",5) == 0) {
-      fprintf(pAliceInp,"*\n*Cut for delta rays by electrons ????????????\n");
-      fprintf(pAliceInp,"*Generated from call: SetCut('DCUTE',cut);\n");
-      // -fCutValue[i];
-      // zero = ignored
-      // zero = ignored
-      // three = lower bound of the material indices in which the respective thresholds apply
-      // fLastMaterial = upper bound of the material indices in which the respective thresholds apply
-      fprintf(pAliceInp,"EMFCUT    %10.4g%10.1f%10.1f%10.1f%10.1f\n",-fCutValue[i],zero,zero,three,fLastMaterial);
-      fprintf(pAliceInp,"DELTARAY  %10.4g%10.3f%10.3f%10.1f%10.1f%10.1f\n",fCutValue[i], 100., 1.03, 3.0, fLastMaterial, 1.0);
-      fprintf(pAliceInp,"STEPSIZE  %10.4g%10.3f%10.3f%10.1f%10.1f\n", 0.1, 1.0, 1.00, 
-             Float_t(gGeoManager->GetListOfUVolumes()->GetEntriesFast()-1), 1.0);
-    }
-    
-    //
-    // time of flight cut in seconds
-    // G4 particles: all
-    // G3 default value: 0.01 GeV
-    //gMC ->SetCut("TOFMAX",tofmax); // time of flight cuts in seconds
-    else if (strncmp(&sCutFlag[i][0],"TOFMAX",6) == 0) {
-      fprintf(pAliceInp,"*\n*Time of flight cuts in seconds\n");
-      fprintf(pAliceInp,"*Generated from call: SetCut('TOFMAX',tofmax);\n");
-      // zero = ignored
-      // zero = ignored
-      // -6.0 = lower bound of the particle numbers for which the transport time cut-off and/or the start signal is to be applied
-      // 64.0 = upper bound of the particle numbers for which the transport time cut-off and/or the start signal is to be applied
-      fprintf(pAliceInp,"TIME-CUT  %10.4g%10.1f%10.1f%10.1f%10.1f\n",fCutValue[i]*1.e9,zero,zero,-6.0,64.0);
-    }
-
-    else {
-      cout << "SetCut for flag=" << &sCutFlag[i][0] << " value=" << fCutValue[i] << " not yet implemented!" << endl;
-    }
+      
   } //end of loop over SetCut calls
-    
+  
 // Add START and STOP card
-   fprintf(pAliceInp,"START     %10.1f\n",fEventsPerRun);
-   fprintf(pAliceInp,"STOP      \n");
-   
+  fprintf(pAliceInp,"START     %10.1f\n",fEventsPerRun);
+  fprintf(pAliceInp,"STOP      \n");
    
+  
 // Close files
-
+  
    fclose(pAliceCoreInp);
    fclose(pAliceFlukaMat);
    fclose(pAliceInp);
+   fclose(pGaliceCuts);
    
 } // end of InitPhysics
 
index 32a39610941e0cb1212778f2a6b7c37802add486..1692926827915575563553d274c839a023be4beb 100644 (file)
@@ -120,7 +120,9 @@ class TFluka : public TVirtualMC {
   
   // set methods
   virtual void     SetProcess(const char* flagName, Int_t flagValue);
+    virtual void     SetProcess(const char* flagName, Int_t flagValue, Int_t imed);
   virtual void     SetCut(const char* cutName, Double_t cutValue);
+  virtual void     SetCut(const char* cutName, Double_t cutValue, Int_t imed);
   virtual Double_t Xsec(char*, Double_t, Int_t, Int_t);
   
   // particle table usage         
@@ -267,10 +269,10 @@ class TFluka : public TVirtualMC {
   void SetInputFileName(const char* n) {sInputFileName = n;}
 
   // - SetProcess and SetCut
-  Int_t GetProcessNb() const {return iNbOfProc;}
-  void SetProcessNb(Int_t l) {iNbOfProc = l;}
-  Int_t GetCutNb() const {return iNbOfProc;}
-  void SetCutNb(Int_t l) {iNbOfCut = l;}
+  Int_t GetProcessNb() const {return fNbOfProc;}
+  void SetProcessNb(Int_t l) {fNbOfProc = l;}
+  Int_t GetCutNb() const {return fNbOfProc;}
+  void SetCutNb(Int_t l) {fNbOfCut = l;}
 
   // - Verbosity level
   Int_t GetVerbosityLevel() const {return fVerbosityLevel;}
@@ -342,12 +344,14 @@ class TFluka : public TVirtualMC {
   Bool_t   fTrackIsExiting;   // Flag for track exiting  
   Bool_t   fTrackIsNew;       // Flag for new track
   //variables for SetProcess and SetCut
-  Int_t    iNbOfProc;
-  Int_t    iProcessValue[100];
-  Char_t   sProcessFlag[100][5];
-  Int_t    iNbOfCut;
-  Double_t fCutValue[100];
-  Char_t   sCutFlag[100][7];
+  Int_t    fNbOfProc;
+  Int_t    fProcessValue[1000];
+  Int_t    fProcessMedium[1000];
+  Char_t   fProcessFlag[1000][5];
+  Int_t    fNbOfCut;
+  Double_t fCutValue[1000];
+  Char_t   fCutFlag[1000][7];
+  Int_t    fCutMedium[1000];
 
   //Geometry through TGeo
   Int_t*               fMaterials;         //!Array of indices