FMD/AliFMDDetector.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved.      *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15 /* $Id$ */
  16 /** @file    AliFMDDetector.cxx
  17     @author  Christian Holm Christensen <cholm@nbi.dk>
  18     @date    Mon Mar 27 12:36:27 2006
  19     @brief   Sub-detector base class implementation
  20     @ingroup FMD_base
  21 */
  22
  23 //____________________________________________________________________
  24 //
  25 // AliFMDDetector.
  26 //
  27 // Base class for concrete FMD detectors, like AliFMD1, AliFMD2,
  28 // AliFMD3.
  29 // Utility class to help implement the FMD geometry.  This provides
  30 // the interface for the concrete geometry implementations of the FMD
  31 // sub-detectors.
  32 //
  33 // The AliFMDGeometry object owns the AliFMDDetector objects
  34 //
  35 // Latest changes by Christian Holm Christensen
  36 //
  37 #include "AliFMDDetector.h"     // ALIFMDSUBDETECTOR_H
  38 #include "AliFMDRing.h"         // ALIFMDRING_H
  39 #include "AliLog.h"             // ALILOG_H
  40 #include <TGeoManager.h>        // ROOT_TGeoManager
  41 #include <TGeoMatrix.h>         // ROOT_TGeoMatrix
  42 // #include <TMath.h>              // ROOT_TMath
  43
  44 //====================================================================
  45 ClassImp(AliFMDDetector)
  46 #if 0
  47   ; // This is here to keep Emacs for indenting the next line
  48 #endif
  49
  50 //____________________________________________________________________
  51 AliFMDDetector::AliFMDDetector(Int_t id, AliFMDRing* inner, AliFMDRing* outer)
  52   : TNamed(Form("FMD%d", id), "Forward multiplicity ring"),
  53     fId(id),
  54     fInnerZ(0.),
  55     fOuterZ(0.),
  56     fHoneycombThickness(0.),
  57     fAlThickness(0.),
  58     fInnerHoneyLowR(0.),
  59     fInnerHoneyHighR(0.),
  60     fOuterHoneyLowR(0.),
  61     fOuterHoneyHighR(0.),
  62     fInner(inner),
  63     fOuter(outer),
  64     fInnerTransforms(0),
  65     fOuterTransforms(0)
  66 {
  67   // Constructor
  68   //
  69   //   ID         Id of detector (1,2, or 3)
  70   //   INNER      Inner ring geometry
  71   //   OUTER      Outer ring geometry (if any)
  72   //
  73   SetHoneycombThickness();
  74   SetAlThickness();
  75   SetInnerHoneyLowR(0);
  76   SetInnerHoneyHighR(0);
  77   SetInnerZ(0);
  78   SetOuterZ(0);
  79   SetOuterHoneyLowR(0);
  80   SetOuterHoneyHighR(0);
  81 }
  82
  83 //____________________________________________________________________
  84 AliFMDDetector::AliFMDDetector(const AliFMDDetector& other)
  85   : TNamed(other),
  86     fId(other.fId),
  87     fInnerZ(0.),
  88     fOuterZ(0.),
  89     fHoneycombThickness(0.),
  90     fAlThickness(0.),
  91     fInnerHoneyLowR(0.),
  92     fInnerHoneyHighR(0.),
  93     fOuterHoneyLowR(0.),
  94     fOuterHoneyHighR(0.),
  95     fInner(other.fInner),
  96     fOuter(other.fOuter),
  97     fInnerTransforms(other.fInnerTransforms),
  98     fOuterTransforms(other.fOuterTransforms)
  99 {
 100   // Copy constructor
 101   SetHoneycombThickness(other.GetHoneycombThickness());
 102   SetAlThickness(other.GetAlThickness());
 103   SetInnerHoneyLowR(other.GetInnerHoneyLowR());
 104   SetInnerHoneyHighR(other.GetInnerHoneyHighR());
 105   SetInnerZ(other.GetInnerZ());
 106   SetOuterZ(other.GetOuterZ());
 107   SetOuterHoneyLowR(other.GetOuterHoneyLowR());
 108   SetOuterHoneyHighR(other.GetOuterHoneyHighR());
 109 }
 110
 111 //____________________________________________________________________
 112 AliFMDDetector&
 113 AliFMDDetector::operator=(const AliFMDDetector& other)
 114 {
 115   // Assignment operator
 116   SetName(other.GetName());
 117   SetTitle(other.GetTitle());
 118   fId              = other.fId;
 119   fInner           = other.fInner;
 120   fOuter           = other.fOuter;
 121   fInnerTransforms = other.fInnerTransforms;
 122   fOuterTransforms = other.fOuterTransforms;
 123   SetHoneycombThickness(other.GetHoneycombThickness());
 124   SetAlThickness(other.GetAlThickness());
 125   SetInnerHoneyLowR(other.GetInnerHoneyLowR());
 126   SetInnerHoneyHighR(other.GetInnerHoneyHighR());
 127   SetInnerZ(other.GetInnerZ());
 128   SetOuterZ(other.GetOuterZ());
 129   SetOuterHoneyLowR(other.GetOuterHoneyLowR());
 130   SetOuterHoneyHighR(other.GetOuterHoneyHighR());
 131   return *this;
 132 }
 133
 134 //____________________________________________________________________
 135 void
 136 AliFMDDetector::Init()
 137 {
 138   // Initialize.
 139   if (fInner) {
 140     SetInnerHoneyLowR(fInner->GetLowR() + 1.);
 141     SetInnerHoneyHighR(fInner->GetHighR() + 1.);
 142   }
 143   if (fOuter) {
 144     SetOuterHoneyLowR(fOuter->GetLowR() + 1.);
 145     SetOuterHoneyHighR(fOuter->GetHighR() + 1.);
 146   }
 147 }
 148
 149 //____________________________________________________________________
 150 Bool_t
 151 AliFMDDetector::HasAllTransforms(Char_t ring) const
 152 {
 153   // Check if we got all transformations for a given ring.  Return
 154   // true in that case.
 155   AliFMDRing* r = GetRing(ring);
 156   if (!r) return kTRUE;
 157   TObjArray* matricies = (r == fInner ? fInnerTransforms : fOuterTransforms);
 158   if (!matricies) return kTRUE;
 159   if (matricies->GetEntries() == r->GetNModules()) return kTRUE;
 160   return kFALSE;
 161 }
 162
 163 #define IS_NODE_THIS(name) \
 164   (name[0] == 'F' && name[2] == 'M' && name[1] == Char_t(48+fId) && \
 165    (name[3] == 'T' || name[3] == 'B'))
 166 #define IS_NODE_SENSOR(name) \
 167   (name[0] == 'F' && name[2] == 'S' && name[3] == 'E')
 168
 169 //____________________________________________________________________
 170 void
 171 AliFMDDetector::InitTransformations()
 172 {
 173   // Find all local<->global transformations for this detector.
 174   if ((!fInner || (fInner && fInnerTransforms)) &&
 175       (!fOuter || (fOuter && fOuterTransforms))) {
 176     AliDebug(5, Form("Transforms for FMD%d already registered", fId));
 177     return;
 178   }
 179   AliDebug(5, Form("Initializing transforms for FMD%d", fId));
 180   if (!gGeoManager) {
 181     AliFatal("No TGeoManager defined");
 182     return;
 183   }
 184   TGeoVolume* topVolume = gGeoManager->GetTopVolume();
 185   if (!topVolume) {
 186     AliFatal("No top-level volume defined");
 187     return;
 188   }
 189   // Make container of transforms
 190   if (fInner && !fInnerTransforms)
 191     fInnerTransforms = new TObjArray(fInner->GetNModules());
 192   if (fOuter && !fOuterTransforms)
 193     fOuterTransforms = new TObjArray(fOuter->GetNModules());
 194
 195   // Make an iterator
 196   TGeoIterator next(topVolume);
 197   TGeoNode* node = 0;
 198
 199   // Find the node corresponding to this detector, and then find the
 200   // sensor volumes
 201   Bool_t thisNodeFound = kFALSE;
 202   Bool_t allInners     = HasAllTransforms('I');
 203   Bool_t allOuters     = HasAllTransforms('O');
 204
 205   while ((node = static_cast<TGeoNode*>(next()))
 206          && !(allInners && allOuters)) {
 207     // Get nodes names
 208     const Char_t* name = node->GetName();
 209     if (!name) continue;
 210     AliDebug(50, Form("Got volume %s", name));
 211     // Check if this node is this detector
 212     // The base offset for numbers in the ASCII table is 48
 213     if (IS_NODE_THIS(name)) {
 214       AliDebug(20, Form("Found detector node '%s' for FMD%d", name, fId));
 215       thisNodeFound = kTRUE;
 216     }
 217     // if the detector was found, then we're on that branch, and we
 218     // check if this node represents a module in that branch.
 219     if (thisNodeFound && IS_NODE_SENSOR(name)) {
 220       AliDebug(20, Form("Found sensor node '%s' for FMD%d", name, fId));
 221       // Get the ring Id.
 222       Char_t ringid = name[1];
 223
 224       // Get the approprate ring
 225       AliFMDRing* ring = GetRing(ringid);
 226       if (!ring) continue;
 227
 228       // Check whether we have all the modules we need for this ring,
 229       // and if so, go on to the next node.
 230       Bool_t& done = (ring == fInner ? allInners : allOuters);
 231       if ((done = HasAllTransforms(ringid))) {
 232         AliDebug(20, Form("Already has all module transforms for ring %c",
 233                          ringid));
 234         continue;
 235       }
 236
 237       // Get the approprate container
 238       TObjArray* matricies = (ringid == 'i' || ringid == 'I'
 239                               ? fInnerTransforms : fOuterTransforms);
 240
 241       // Get the copy (module) number, and check that it hasn't
 242       // already been added to the container.
 243       Int_t copy  = node->GetNumber();
 244       if (matricies->At(copy)) {
 245         AliWarning(Form("Have a transformation for module %d in ring %c",
 246                         copy, ringid));
 247         continue;
 248       }
 249
 250       // Get the global transformation matrix, and store it.
 251       TGeoMatrix*  trans = new TGeoHMatrix(*(next.GetCurrentMatrix()));
 252       matricies->AddAt(trans, copy);
 253
 254     }
 255   }
 256 }
 257
 258 //____________________________________________________________________
 259 AliFMDRing*
 260 AliFMDDetector::GetRing(Char_t id) const
 261 {
 262   // Get the specified ring
 263   //
 264   //   ID      Id of ring ('I' or 'O')
 265   //
 266   switch (id) {
 267   case 'i':
 268   case 'I': return GetInner();
 269   case 'o':
 270   case 'O': return GetOuter();
 271   }
 272   return 0;
 273 }
 274
 275 //____________________________________________________________________
 276 Double_t
 277 AliFMDDetector::GetRingZ(Char_t id) const
 278 {
 279   // Get the z-coordinate specified ring
 280   //
 281   //   ID      Id of ring ('I' or 'O')
 282   //
 283   switch (id) {
 284   case 'i':
 285   case 'I': return GetInnerZ();
 286   case 'o':
 287   case 'O': return GetOuterZ();
 288   }
 289   return 0;
 290 }
 291
 292 //____________________________________________________________________
 293 TGeoMatrix*
 294 AliFMDDetector::FindTransform(Char_t ring, UShort_t sector) const
 295 {
 296   // Find the transformation that corresponds to sector sector in ring
 297   // ring.
 298   TObjArray* matricies = 0;
 299   switch (ring) {
 300   case 'i': case 'I': matricies = fInnerTransforms; break;
 301   case 'o': case 'O': matricies = fOuterTransforms; break;
 302   }
 303   if (!matricies) {
 304     AliWarning(Form("Unknown ring %c of FMD%d", ring, fId));
 305     return 0;
 306   }
 307   UInt_t module = sector / 2;
 308   TGeoMatrix* m = static_cast<TGeoMatrix*>(matricies->At(module));
 309   if (!m) {
 310     AliWarning(Form("No matrix found for sector %d in FMD%d%c",
 311                     sector, fId, ring));
 312     return 0;
 313   }
 314   return m;
 315 }
 316
 317
 318 //____________________________________________________________________
 319 void
 320 AliFMDDetector::Detector2XYZ(Char_t   ring,
 321                              UShort_t sector,
 322                              UShort_t strip,
 323                              Double_t& x,
 324                              Double_t& y,
 325                              Double_t& z) const
 326 {
 327   // Translate detector coordinates (this,ring,sector,strip) into
 328   // (x,y,z) coordinates (in global reference frame)
 329   AliFMDRing* r = GetRing(ring);
 330   if (!r) return;
 331   TGeoMatrix* m = FindTransform(ring, sector);
 332   if (!m) return;
 333   Double_t rho      = r->GetStripRadius(strip);
 334   Double_t phi      = ((sector % 2) - .5) * r->GetTheta();
 335   Double_t siThick  = r->GetSiThickness();
 336   Double_t modThick = (siThick
 337                        + r->GetPrintboardThickness()
 338                        + r->GetCopperThickness()
 339                        + r->GetChipThickness()
 340                        + r->GetSpacing());
 341   AliDebug(30,Form("Rho %7.3f, angle %7.3f", rho, phi));
 342 # define DEGRAD TMath::Pi() / 180.
 343   Double_t local[]  = { rho * TMath::Cos(phi * DEGRAD),
 344                         rho * TMath::Sin(phi * DEGRAD),
 345                         -modThick + siThick / 2 };
 346   Double_t master[3];
 347   AliDebug(30, Form("Local (%7.3f,%7.3f,%7.3f)",local[0], local[1], local[2]));
 348   m->LocalToMaster(local, master);
 349   AliDebug(30, Form("Master (%7.3f,%7.3f,%7.3f)",
 350                     master[0],master[1],master[2]));
 351   x = master[0];
 352   y = master[1];
 353   z = master[2];
 354 }
 355
 356 //____________________________________________________________________
 357 Bool_t
 358 AliFMDDetector::XYZ2Detector(Double_t  x,
 359                              Double_t  y,
 360                              Double_t  z,
 361                              Char_t&   ring,
 362                              UShort_t& sector,
 363                              UShort_t& strip) const
 364 {
 365   // Translate (x,y,z) coordinates (in global reference frame) into
 366   // detector coordinates (this,ring,sector,strip).
 367   AliFMDRing* rng = 0;
 368   ring = -1;
 369   for (int j = 0; j < 2; j++) {
 370     rng = GetRing(j == 0 ? 'I'  : 'O');
 371     if (!rng) continue;
 372     Double_t ringZ    = GetRingZ(j == 0 ? 'I'  : 'O');
 373     Double_t modSpace = TMath::Sign(rng->GetModuleSpacing(), ringZ);
 374     if (TMath::Abs(z - ringZ) < 0.01 ||
 375         TMath::Abs(z - ringZ + modSpace) < 0.01) break;
 376     rng = 0;
 377   }
 378   if (rng && rng->XYZ2Detector(x, y, z - GetRingZ(rng->GetId()),
 379                                sector, strip)) {
 380     ring = rng->GetId();
 381     return kTRUE;
 382   }
 383   return kFALSE;
 384 }
 385
 386
 387
 388 //____________________________________________________________________
 389 //
 390 // EOF
 391 //