Violation fixes
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 Mar 2010 18:42:37 +0000 (18:42 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 Mar 2010 18:42:37 +0000 (18:42 +0000)
FMD/AliFMD.cxx
FMD/AliFMD.h
FMD/AliFMDRing.cxx
FMD/DrawFMD.C

index 1bc97d3..10124ea 100644 (file)
@@ -432,6 +432,57 @@ void AliFMD::CreateMaterials()
 
 //____________________________________________________________________
 void  
+AliFMD::SetTrackingParameters(Int_t imed, 
+                             Float_t gamma,                 
+                             Float_t electron, 
+                             Float_t neutral_hadron, 
+                             Float_t charged_hadron, 
+                             Float_t muon,
+                             Float_t electron_bremstrahlung, 
+                             Float_t muon__bremstrahlung, 
+                             Float_t electron_delta,
+                             Float_t muon_delta,
+                             Float_t muon_pair,
+                             Int_t   annihilation, 
+                             Int_t   bremstrahlung, 
+                             Int_t   compton_scattering, 
+                             Int_t   decay,
+                             Int_t   delta_ray, 
+                             Int_t   hadronic, 
+                             Int_t   energy_loss, 
+                             Int_t   multiple_scattering, 
+                             Int_t   pair_production, 
+                             Int_t   photon_production, 
+                             Int_t   rayleigh_scattering)
+{
+  if (!gMC) return;
+  TArrayI& idtmed = *(GetIdtmed());
+  Int_t    iimed  = idtmed[imed];
+  gMC->Gstpar(iimed, "CUTGAM", gamma);
+  gMC->Gstpar(iimed, "CUTELE", electron);
+  gMC->Gstpar(iimed, "CUTNEU", neutral_hadron);
+  gMC->Gstpar(iimed, "CUTHAD", charged_hadron);
+  gMC->Gstpar(iimed, "CUTMUO", muon);
+  gMC->Gstpar(iimed, "BCUTE",  electron_bremstrahlung);
+  gMC->Gstpar(iimed, "BCUTM",  muon__bremstrahlung);
+  gMC->Gstpar(iimed, "DCUTE",  electron_delta);
+  gMC->Gstpar(iimed, "DCUTM",  muon_delta);
+  gMC->Gstpar(iimed, "PPCUTM", muon_pair);
+  gMC->Gstpar(iimed, "ANNI",   Float_t(annihilation));
+  gMC->Gstpar(iimed, "BREM",   Float_t(bremstrahlung));
+  gMC->Gstpar(iimed, "COMP",   Float_t(compton_scattering));
+  gMC->Gstpar(iimed, "DCAY",   Float_t(decay));
+  gMC->Gstpar(iimed, "DRAY",   Float_t(delta_ray));
+  gMC->Gstpar(iimed, "HADR",   Float_t(hadronic));
+  gMC->Gstpar(iimed, "LOSS",   Float_t(energy_loss));
+  gMC->Gstpar(iimed, "MULS",   Float_t(multiple_scattering));
+  gMC->Gstpar(iimed, "PAIR",   Float_t(pair_production));
+  gMC->Gstpar(iimed, "PHOT",   Float_t(photon_production));
+  gMC->Gstpar(iimed, "RAYL",   Float_t(rayleigh_scattering));
+}
+
+//____________________________________________________________________
+void  
 AliFMD::Init()
 {
   // Initialize the detector 
index 442fe86..e93b1d8 100644 (file)
@@ -334,6 +334,55 @@ public:
       -        @c FMD @c Plastic$ Plastic (Support legs for the hybrid cards)
   */
   virtual void   CreateMaterials(); 
+  /** 
+   * Declare tracking parameters for a medium 
+   * 
+   * Cut offs are in GeV. 
+   * @param imed                     Medium identifier
+   * @param gamma                    Cut off for tracking photons
+   * @param electron                 Cut off for tracking electrons
+   * @param neutral_hadron           Cut off for tracking neutral hadrons
+   * @param charged_hadron           Cut off for tracking charged hadrons
+   * @param muon                     Cut off for tracking muons
+   * @param electron_bremstrahlung   Cut off for tracking electron brehmstralung
+   * @param muon__bremstrahlung      Cut off for tracking muon brehmstralung
+   * @param electron_delta           Cut off for tracking delta electrons
+   * @param muon_delta               Cut off for tracking delta muons
+   * @param muon_pair                Cut off for muon->ee pair production
+   * @param annihilation             Enable annihilation
+   * @param bremstrahlung            Enable brehmstralung
+   * @param compton_scattering       Enable Compton scattering
+   * @param decay                    Enable decays
+   * @param delta_ray                Enable delta rays
+   * @param hadronic                 Enable hadronic interactions
+   * @param energy_loss              Enable energy loss
+   * @param multiple_scattering      Enable multiple scattering
+   * @param pair_production          Enable pair production
+   * @param photon_production        Enable cherenkov photon production
+   * @param rayleigh_scattering      Enable rayleigh scattering
+   */ 
+  void SetTrackingParameters(Int_t imed, 
+                            Float_t gamma,                 
+                            Float_t electron, 
+                            Float_t neutral_hadron, 
+                            Float_t charged_hadron, 
+                            Float_t muon,
+                            Float_t electron_bremstrahlung, 
+                            Float_t muon__bremstrahlung, 
+                            Float_t electron_delta,
+                            Float_t muon_delta,
+                            Float_t muon_pair,
+                            Int_t   annihilation, 
+                            Int_t   bremstrahlung, 
+                            Int_t   compton_scattering, 
+                            Int_t   decay,
+                            Int_t   delta_ray, 
+                            Int_t   hadronic, 
+                            Int_t   energy_loss, 
+                            Int_t   multiple_scattering, 
+                            Int_t   pair_production, 
+                            Int_t   photon_production, 
+                            Int_t   rayleigh_scattering);
   /** Initialize this detector */
   virtual void   Init();
   /** This member function is called when ever a track deposites
index 376a2ce..6eebbcd 100644 (file)
@@ -70,7 +70,11 @@ AliFMDRing::AliFMDRing(Char_t id)
     fHybridVerticies(0),
     fFeetPositions(0)
 {
-  // CTOR
+  // Constructor 
+  // 
+  // Parameters: 
+  //    id      Type of ring (either 'I' or 'O') 
+  // 
   SetBondingWidth();
   SetWaferRadius();
   SetSiThickness();
@@ -148,6 +152,9 @@ void
 AliFMDRing::Init()
 {
   // Initialize 
+  // 
+  // All derived quantities are calculated here. 
+  // 
 #if 0
   Double_t tanTheta  = TMath::Tan(fTheta * TMath::Pi() / 180.);
   Double_t tanTheta2 = TMath::Power(tanTheta,2);
@@ -189,6 +196,11 @@ TVector2*
 AliFMDRing::GetVertex(Int_t i) const
 {
   // Get the i'th vertex of polygon shape
+  // 
+  // the polygon shape describes the shape of the rings' sensors
+  // 
+  // Parameters: 
+  //     i    The vertex number to get (from 0 to 5)
   return static_cast<TVector2*>(fVerticies.At(i));
 }
 
@@ -197,6 +209,11 @@ TVector2*
 AliFMDRing::GetSensorVertex(Int_t i) const
 {
   // Get the i'th vertex of polygon shape
+  // 
+  // the polygon shape describes the shape of the rings' sensors
+  // 
+  // Parameters: 
+  //     i    The vertex number to get (from 0 to 5)
   return static_cast<TVector2*>(fSensorVerticies.At(i));
 }
 
@@ -205,6 +222,11 @@ TVector2*
 AliFMDRing::GetHybridVertex(Int_t i) const
 {
   // Get the i'th vertex of polygon shape
+  // 
+  // the polygon shape describes the shape of the rings' hybrid cards
+  // 
+  // Parameters: 
+  //     i    The vertex number to get (from 0 to 5)
   return static_cast<TVector2*>(fHybridVerticies.At(i));
 }
 
@@ -213,6 +235,11 @@ TVector2*
 AliFMDRing::GetFootPosition(Int_t i) const
 {
   // Get the i'th vertex of polygon shape
+  // 
+  // The feet are attached to the hybrid cards
+  // 
+  // Parameters: 
+  //     i    The foot number to get (from 0 to 2)
   return static_cast<TVector2*>(fFeetPositions.At(i));
 }
 
@@ -221,6 +248,9 @@ Double_t
 AliFMDRing::GetStripRadius(UShort_t strip) const
 {
   // Return the nominal strip radius 
+  // 
+  // Parameter 
+  //   strip    Strip number (0-511 for inners, 0-255 for outers)
   Double_t rmax     = GetMaxR();
   Double_t stripoff = GetMinR();
   Double_t dstrip   = (rmax - stripoff) / GetNStrips();
@@ -231,6 +261,16 @@ AliFMDRing::GetStripRadius(UShort_t strip) const
 Double_t
 AliFMDRing::GetModuleDepth() const
 {
+  // Get the total depth of a module (sensor + hybrid card) 
+  // 
+  // The depth is the sum of 
+  // 
+  //   The silicon thickness 
+  //   The thickness of spacers between the silicon and hybrid
+  //   The thickness of the hybrid PCB
+  //   The thickness of the copper layer in the PCB
+  //   The thickness of the chip layer in the PCB
+  //   The height of the legs
   return (GetSiThickness() 
          + GetSpacing() 
          + GetPrintboardThickness()
@@ -244,6 +284,8 @@ AliFMDRing::GetModuleDepth() const
 Double_t
 AliFMDRing::GetFullDepth() const
 {
+  // Get the full depth of this ring, including the honeycomb, 
+  // digitizer and card. 
   return (GetModuleDepth() 
          + GetModuleSpacing()
          + GetHoneycombThickness()
@@ -263,6 +305,16 @@ AliFMDRing::Detector2XYZ(UShort_t sector,
 {
   // Translate detector coordinates (this,sector,strip) to global
   // coordinates (x,y,z)
+  // 
+  // Parameters 
+  //    sector        Sector number in this ring 
+  //    strip         Strip number in this ring 
+  //    x             On return, the global X coordinate
+  //    y             On return, the global Y coordinate 
+  //    z             On return, the z coordinate in the ring plane 
+  //
+  // The ring plane is the plane half way between the two sensor
+  // layers. 
   if (sector >= GetNSectors()) {
     Error("Detector2XYZ", "Invalid sector number %d (>=%d) in ring %c", 
          sector, GetNSectors(), fId);
@@ -291,6 +343,14 @@ AliFMDRing::XYZ2Detector(Double_t  x,
 {
   // Translate global coordinates (x,y,z) to detector coordinates
   // (this,sector,strip)
+  // 
+  //  Parameters: 
+  //     x       Global x coordinate 
+  //     y       Global y coordinate
+  //     z       Global y coordinate
+  //     sector  On return, the sector number in this ring
+  //     strip   On return, the strip number in this ring
+  // 
   sector = strip = 0;
   Double_t r = TMath::Sqrt(x * x + y * y);
   Int_t str = Int_t((r - fMinR) / GetPitch());
@@ -314,6 +374,11 @@ AliFMDRing::XYZ2Detector(Double_t  x,
 Float_t 
 AliFMDRing::GetStripLength(UShort_t strip) const 
 {
+  // Get the length of a strip 
+  // 
+  // Parameters:
+  //   strip     Strip number (0-511 for inners, 0-255 for outers)
+  // 
   if(strip >= GetNStrips())
     Error("GetStripLength", "Invalid strip number %d (>=%d)", 
          strip, GetNStrips(), fId);
@@ -325,24 +390,27 @@ AliFMDRing::GetStripLength(UShort_t strip) const
   TVector2* corner1  = GetVertex(2);  
   TVector2* corner2  = GetVertex(3);
   
-  Float_t slope      = (corner1->Y() - corner2->Y()) / (corner1->X() - corner2->X());
-  Float_t constant   = (corner2->Y()*corner1->X()-(corner2->X()*corner1->Y())) / (corner1->X() - corner2->X());
+  Float_t slope      = ((corner1->Y() - corner2->Y()) / 
+                       (corner1->X() - corner2->X()));
+  Float_t constant   = ((corner2->Y() * corner1->X() - 
+                        (corner2->X()*corner1->Y())) / 
+                       (corner1->X() - corner2->X()));
   Float_t radius     = GetMinR() + strip*segment;
   
-  Float_t d          = TMath::Power(TMath::Abs(radius*slope),2) + TMath::Power(radius,2) - TMath::Power(constant,2);
+  Float_t d          = (TMath::Power(TMath::Abs(radius*slope),2) + 
+                       TMath::Power(radius,2) - TMath::Power(constant,2));
   
   Float_t arclength  = GetBaseStripLength(strip);
   if(d>0) {
-    
-    Float_t x        = (-1*TMath::Sqrt(d) -slope*constant) / (1+TMath::Power(slope,2));
+    Float_t x        = ((-1 * TMath::Sqrt(d) -slope*constant) / 
+                       (1 + TMath::Power(slope,2)));
     Float_t y        = slope*x + constant;
     Float_t theta    = TMath::ATan2(x,y);
     
     if(x < corner1->X() && y > corner1->Y()) {
-      arclength = radius*theta;                        //One sector since theta is by definition half-hybrid
-      
+      //One sector since theta is by definition half-hybrid
+      arclength = radius*theta;
     }
-    
   }
   
   return arclength;
@@ -353,11 +421,15 @@ AliFMDRing::GetStripLength(UShort_t strip) const
 Float_t 
 AliFMDRing::GetBaseStripLength(UShort_t strip) const 
 {  
+  // Get the basic strip length 
+  // 
+  // Parameters:
+  //   strip    Strip number
   Float_t rad             = GetMaxR()-GetMinR();
   Float_t segment         = rad / GetNStrips();
-  Float_t basearc         = 2*TMath::Pi() / (0.5*GetNSectors()); // One hybrid: 36 degrees inner, 18 outer
+  Float_t basearc         = 2*TMath::Pi() / (0.5*GetNSectors()); 
   Float_t radius          = GetMinR() + strip*segment;
-  Float_t basearclength   = 0.5*basearc * radius;                // One sector   
+  Float_t basearclength   = 0.5*basearc * radius;                
   
   return basearclength;
 }
index cbcd7d1..e240726 100644 (file)
@@ -6,24 +6,43 @@
 void DrawFMD(const char* file="geometry.root", const char* option="ogl")
 {
 #if 1
+  AliCDBManager* cdb = AliCDBManager::Instance();
+  cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+  cdb->SetRun(0);
   AliGeomManager::LoadGeometry(file);
   TGeoVolume* top = gGeoManager->GetTopVolume();
-  top->InvisibleAll(kTRUE);
-  for (Int_t i = 1; i <= 3; i++) { 
-    for (Int_t j = 0; j < 2; j++) { 
-      TString name(Form("F%dM%c", i, (j == 0 ? 'T' : 'B')));
-      TGeoVolume* v = gGeoManager->FindVolumeFast(name.Data());
-      if (!v) { 
-       std::cerr << "FMD" << i << " " 
-                 << (j == 0 ? "top" : "bottom") 
-                 << " Volume " << name << " not found" << std::endl;
-       continue;
+  TGeoIterator next(top);
+  TGeoNode* node = 0;
+  while ((node = next())) {
+    TGeoVolume* v = node->GetVolume();
+    v->SetVisibility(kFALSE);
+    v->InvisibleAll(kTRUE);
+    v->VisibleDaughters(kFALSE);
+
+    TString name(v->GetName());
+    if (name[0] == 'F') { 
+      if (name[1] == '1' || name[1] == '2' || name[1] == '3' ||
+         name[1] == 'I' || name[1] == 'O' || name[1] == 'M') {
+        v->SetVisibility(kTRUE);
+        v->InvisibleAll(kFALSE);
+        v->VisibleDaughters(kTRUE);
+        std::cout << "Making " << name << " visible" << std::endl;
+        continue;
       }
-      v->InvisibleAll(kFALSE);
-      v->SetVisDaughters(kTRUE);
-      v->SetVisLeaves(kTRUE);
     }
+    if (name[0] == 'C') { 
+      if ((name[1] == 'P' || name[1] == 'p') && 
+         (name[2] == '1' || name[2] == '2' || name[3] == '3')) {
+       v->SetVisibility(kTRUE);
+       v->InvisibleAll(kFALSE);
+       v->VisibleDaughters(kTRUE);
+       std::cout << "Making " << name << " visible" << std::endl;
+       continue;       
+      }
   }
+  // for (
+  gGeoManager->SetVisLevel(5);
+  top->InvisibleAll(kFALSE);
   top->Draw(option);
 
 #else