[u/mrichter/AliRoot.git] / FMD / AliFMDDetector.cxx

/**************************************************************************
 * Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved.      *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
/* $Id$ */
/** @file    AliFMDDetector.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:36:27 2006
    @brief   Sub-detector base class implementation
    @ingroup FMD_base
*/

//____________________________________________________________________
//
// AliFMDDetector.   
//
// Base class for concrete FMD detectors, like AliFMD1, AliFMD2,
// AliFMD3. 
// Utility class to help implement the FMD geometry.  This provides
// the interface for the concrete geometry implementations of the FMD
// sub-detectors. 
//
// The AliFMDGeometry object owns the AliFMDDetector objects
//
// Latest changes by Christian Holm Christensen
//

#include <TGeoManager.h>	// ROOT_TGeoManager 
#include <TGeoPhysicalNode.h>   // ROOT_TGeoPhysicalNode
#include <TGeoMatrix.h>		// ROOT_TGeoMatrix 
#include <TMath.h>              // ROOT_TMath

#include "AliFMDDetector.h"	// ALIFMDSUBDETECTOR_H
#include "AliFMDRing.h"		// ALIFMDRING_H
#include "AliFMDDebug.h"		// ALIFMDDEBUG_H ALILOG_H

//====================================================================
ClassImp(AliFMDDetector)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliFMDDetector::AliFMDDetector(Int_t id, AliFMDRing* inner, AliFMDRing* outer) 
  : TNamed(Form("FMD%d", id), "Forward multiplicity ring"), 
    fId(id), 
    fInnerZ(0.),
    fOuterZ(0.),
    fInnerHoneyLowR(0.),
    fInnerHoneyHighR(0.),
    fOuterHoneyLowR(0.),
    fOuterHoneyHighR(0.),
    fInner(inner),
    fOuter(outer), 
    fInnerTransforms(0),
    fOuterTransforms(0)
{
  // Constructor
  // 
  //   ID         Id of detector (1,2, or 3)
  //   INNER      Inner ring geometry 
  //   OUTER      Outer ring geometry (if any)
  // 
  SetInnerHoneyLowR(0);
  SetInnerHoneyHighR(0);
  SetInnerZ(0);
  SetOuterZ(0);
  SetOuterHoneyLowR(0);
  SetOuterHoneyHighR(0);
}

//____________________________________________________________________
AliFMDDetector::AliFMDDetector(const AliFMDDetector& other)
  : TNamed(other), 
    fId(other.fId),
    fInnerZ(0.),
    fOuterZ(0.),
    fInnerHoneyLowR(0.),
    fInnerHoneyHighR(0.),
    fOuterHoneyLowR(0.),
    fOuterHoneyHighR(0.),
    fInner(other.fInner),
    fOuter(other.fOuter),
    fInnerTransforms(other.fInnerTransforms),
    fOuterTransforms(other.fOuterTransforms)
{
  // Copy constructor 
  SetInnerHoneyLowR(other.GetInnerHoneyLowR());
  SetInnerHoneyHighR(other.GetInnerHoneyHighR());
  SetInnerZ(other.GetInnerZ());
  SetOuterZ(other.GetOuterZ());
  SetOuterHoneyLowR(other.GetOuterHoneyLowR());
  SetOuterHoneyHighR(other.GetOuterHoneyHighR());
}

//____________________________________________________________________
AliFMDDetector&
AliFMDDetector::operator=(const AliFMDDetector& other)
{
  // Assignment operator
  SetName(other.GetName());
  SetTitle(other.GetTitle());
  fId              = other.fId;
  fInner           = other.fInner;
  fOuter           = other.fOuter;
  fInnerTransforms = other.fInnerTransforms;
  fOuterTransforms = other.fOuterTransforms;
  SetInnerHoneyLowR(other.GetInnerHoneyLowR());
  SetInnerHoneyHighR(other.GetInnerHoneyHighR());
  SetInnerZ(other.GetInnerZ());
  SetOuterZ(other.GetOuterZ());
  SetOuterHoneyLowR(other.GetOuterHoneyLowR());
  SetOuterHoneyHighR(other.GetOuterHoneyHighR());
  return *this;
}

//____________________________________________________________________
void
AliFMDDetector::Init()
{
  // Initialize. 
  if (fInner) {
    SetInnerHoneyLowR(fInner->GetLowR() + 1.);
    SetInnerHoneyHighR(fInner->GetHighR() + 1.);
  }
  if (fOuter) {
    SetOuterHoneyLowR(fOuter->GetLowR() + 1.);
    SetOuterHoneyHighR(fOuter->GetHighR() + 1.);
  }  
}

//____________________________________________________________________
Bool_t
AliFMDDetector::HasAllTransforms(Char_t ring) const
{
  // Check if we got all transformations for a given ring.  Return
  // true in that case. 
  AliFMDRing* r = GetRing(ring);
  if (!r) return kTRUE;
  TObjArray* matricies = (r == fInner ? fInnerTransforms : fOuterTransforms);
  if (!matricies) return kTRUE;
  if (matricies->GetEntries() == r->GetNModules()) return kTRUE;
  return kFALSE;
}

#define IS_NODE_THIS(name) \
  (name[0] == 'F' && name[2] == 'M' && name[1] == Char_t(48+fId) && \
   (name[3] == 'T' || name[3] == 'B'))
#define IS_NODE_SENSOR(name)				\
  (name[0] == 'F' && (name[2] == 'B' || name[2] == 'F') && name[3] == 'H')
//#define IS_NODE_SENSOR(name)				
//  (name[0] == 'F' && name[2] == 'S' && name[3] == 'E')
#define IS_NODE_HALF(name) \
  (name[0] == 'F' && name[2] == 'M' && (name[3] == 'B' || name[3] == 'T'))
#define HALF_FORMAT   "FMD/FMD%d_%c"
#define SENSOR_FORMAT "FMD/FMD%d_%c/FMD%c_%02d"

//____________________________________________________________________
void
AliFMDDetector::InitTransformations()
{
  // Find all local<->global transformations for this detector. 
  if ((!fInner || (fInner && fInnerTransforms)) && 
      (!fOuter || (fOuter && fOuterTransforms))) {
    AliFMDDebug(5, ("Transforms for FMD%d already registered", fId));
    return;
  }
  AliFMDDebug(5, ("Initializing transforms for FMD%d", fId));
  if (!gGeoManager) {
    AliFatal("No TGeoManager defined");
    return;
  }

  // Implementation using alignable volume names. 
  // Make container of transforms 
  if (fInner && !fInnerTransforms) 
    fInnerTransforms = new TObjArray(fInner->GetNModules());
  if (fOuter && !fOuterTransforms) 
    fOuterTransforms = new TObjArray(fOuter->GetNModules());
  
  // Loop over bottom/top 
  for (size_t ihalf = 0; ihalf < 2; ihalf++) {
    char  half = (ihalf == 0 ? 'T' : 'B');
    TString path(Form(HALF_FORMAT, fId, half));
    TGeoPNEntry* entry = gGeoManager->GetAlignableEntry(path.Data());
    if (!entry) {
      AliError(Form("Alignable entry for half-detector \"%s\" not found!", 
		    path.Data()));
      continue;
    }
    TGeoPhysicalNode* pn = entry->GetPhysicalNode();
    if (!pn) {
      AliWarning(Form("Making physical volume for \"%s\"", path.Data()));
      pn = gGeoManager->MakeAlignablePN(entry);
      if (!pn) {
	AliError(Form("No physical node for \"%s\"", path.Data()));
	continue;
      }
    }
  }
  
  // Loop over rings 
  for (size_t iring = 0; iring < 2; iring++) {
    char ring = (iring == 0 ? 'I' : 'O');
    TObjArray*  trans = 0;
    AliFMDRing* r     = 0; 
    switch (ring) {
    case 'I': r = fInner; trans = fInnerTransforms; break;
    case 'O': r = fOuter; trans = fOuterTransforms; break; 
    }
    if (!r || !trans) continue;

    Int_t nModules = r->GetNModules();
    if (nModules <= 0) continue;

    // Loop over bottom/top 
    for (size_t ihalf = 0; ihalf < 2; ihalf++) {
      char  half = (ihalf == 0 ? 'T' : 'B');
      Int_t base = (half == 'T' ? 0 : nModules / 2);
      
      // Loop over modules in this half ring 
      for (Int_t imod = 0; imod < nModules / 2; imod++) {
	// Find physical node entry
	TString path(Form(SENSOR_FORMAT, fId, half, ring, base+imod));
	TGeoPNEntry* entry = gGeoManager->GetAlignableEntry(path.Data());
	if (!entry) {
	  AliError(Form("Alignable entry for sensor \"%s\" not found!", 
			path.Data()));
	  continue;
	}
	TGeoPhysicalNode* pn = entry->GetPhysicalNode();
	if (!pn) {
	  AliWarning(Form("Making physical volume for \"%s\"", path.Data()));
	  pn = gGeoManager->MakeAlignablePN(entry);
	  if (!pn) {
	    AliError(Form("No physical node for \"%s\"", path.Data()));
	    continue;
	  }
	}
	
	const TGeoMatrix* pm = pn->GetMatrix();
	if (!pm) {
	  AliError(Form("No matrix for path \"%s\"", path.Data()));
	  continue;
	}
	// Get transformation matrix for this node, and store it. 
	TGeoMatrix*  t = new TGeoHMatrix(*pm);
	trans->AddAt(t, base+imod);
	AliFMDDebug(5, ("Found matrix for path \"%s\": %p",path.Data(),pm));
      }
    }
  }
  if (HasAllTransforms('I') && HasAllTransforms('O')) return;

  // Alternative implementation using TGeoIter. 
  TGeoVolume* topVolume = gGeoManager->GetTopVolume();
  if (!topVolume) {
    AliFatal("No top-level volume defined");
    return;
  }
  // Make an iterator
  TGeoIterator next(topVolume);
  TGeoNode* node = 0;
  
  // Find the node corresponding to this detector, and then find the
  // sensor volumes 
  Bool_t thisNodeFound = kFALSE;
  Bool_t allInners     = HasAllTransforms('I');
  Bool_t allOuters     = HasAllTransforms('O');
  
  while ((node = static_cast<TGeoNode*>(next())) 
	 && !(allInners && allOuters)) {
    // Get nodes names 
    const Char_t* name = node->GetName();
    if (!name) continue;
    AliFMDDebug(50, ("Got volume %s", name));
    // Check if this node is this detector 
    // The base offset for numbers in the ASCII table is 48
    if (IS_NODE_THIS(name)) {
      AliFMDDebug(20, ("Found detector node '%s' for FMD%d", name, fId));
      thisNodeFound = kTRUE;
    }
    // if the detector was found, then we're on that branch, and we
    // check if this node represents a module in that branch.
    if (thisNodeFound && IS_NODE_SENSOR(name)) {
      AliFMDDebug(20, ("Found sensor node '%s' for FMD%d", name, fId));
      // Get the ring Id.
      Char_t ringid = name[1];

      // Get the approprate ring
      AliFMDRing* ring = GetRing(ringid);
      if (!ring) continue;

      // Check whether we have all the modules we need for this ring,
      // and if so, go on to the next node. 
      Bool_t& done = (ring == fInner ? allInners : allOuters);
      if ((done = HasAllTransforms(ringid))) {
	AliFMDDebug(20, ("Already has all module transforms for ring %c", 
			 ringid));
	continue;
      }

      // Get the approprate container
      TObjArray* matricies = (ringid == 'i' || ringid == 'I' 
			      ? fInnerTransforms : fOuterTransforms);

      // Get the copy (module) number, and check that it hasn't
      // already been added to the container. 
      Int_t copy  = node->GetNumber();
      if (matricies->At(copy)) {
	AliWarning(Form("Have a transformation for module %d in ring %c", 
			copy, ringid));
	continue;
      }

      // Get the global transformation matrix, and store it. 
      TGeoMatrix*  trans = new TGeoHMatrix(*(next.GetCurrentMatrix()));
      matricies->AddAt(trans, copy);

    }
  }
}

//____________________________________________________________________
void
AliFMDDetector::SetAlignableVolumes() const
{
  // Set alignable volumes. 
  // This will define the alignable volumes. 
  // That is currently, the modules and the half-rings. 
  
  AliFMDDebug(10, ("Making alignable volumes for FMD%d", fId));
  if (!gGeoManager) {
    AliFatal("No TGeoManager defined");
    return;
  }
  TGeoVolume* topVolume = gGeoManager->GetTopVolume();
  if (!topVolume) {
    AliFatal("No top-level volume defined");
    return;
  }

  // Make an iterator
  TGeoIterator next(topVolume);
  next.Reset(topVolume);
  next.SetTopName(Form("/%s_1", topVolume->GetName()));
  TGeoNode* node = 0;
  
  Int_t nInnerSensor = (fInner ? fInner->GetNModules() : 0);
  Int_t nOuterSensor = (fOuter ? fOuter->GetNModules() : 0);
  // Find the node corresponding to this detector, and then find the
  // sensor volumes 
  Bool_t thisNodeFound = kFALSE;
  Char_t thisHalf      = '\0';
  Int_t  iInnerSensor  = 0;
  Int_t  iOuterSensor  = 0;
  Bool_t hasTop        = false;
  Bool_t hasBottom     = false;
  
  TString path, align;
  while ((node = static_cast<TGeoNode*>(next())) 
	 && (iInnerSensor < nInnerSensor || iOuterSensor < nOuterSensor
	     || !hasBottom || !hasTop)) {
    // Get nodes names 
    const Char_t* name = node->GetName();
    if (!name) continue;
    AliFMDDebug((name[0] == 'F' ? 40 : 50), ("Got volume %s", name));
    // Check if this node is this detector 
    // The base offset for numbers in the ASCII table is 48
    if (IS_NODE_THIS(name)) {
      AliFMDDebug(20, ("Found detector node '%s' for FMD%d", name, fId));
      thisNodeFound = kTRUE;
    }

    // if a half ring is found, then we're on that branch, and we
    // check if this node represents a half ring on that branch 
    if (thisNodeFound && IS_NODE_HALF(name)) {
      AliFMDDebug(30, ("Found half node '%s' for FMD%d", name, fId));
      // Get the half Id.
      thisHalf = name[3];

      // Check if we're done 
      Bool_t done = (thisHalf == 'T' ? hasTop : hasBottom);
      if (done) {
	AliFMDDebug(20, ("Already has all halves for detector %c",name[1]));
	continue;
      }

      switch (thisHalf) {
      case 'T': hasTop = true; break;
      case 'B': hasBottom = true; break;
      default:  
	AliWarning(Form("Unknown part '%c' of FMD%d", thisHalf, fId));
	continue; // because the node is unknown. 
      }
      
      // Get the node path 
      next.GetPath(path);
      align = Form(HALF_FORMAT, fId, thisHalf);
    }
    
    // if the detector was found, then we're on that branch, and we
    // check if this node represents a module in that branch.
    if (thisNodeFound && thisHalf && IS_NODE_SENSOR(name)) {
      AliFMDDebug(30, ("Found sensor node '%s' for FMD%d", name, fId));
      // Get the ring Id.
      Char_t ringid = name[1];

      // check that the ring is valid 
      if (!GetRing(ringid)) {
	AliWarning(Form("Invalid ring %c for FMD%d", ringid, fId));
	continue;
      }

      // Check if we're done
      Bool_t done = false;
      switch (ringid) {
      case 'I': done = iInnerSensor >= nInnerSensor; break;
      case 'O': done = iOuterSensor >= nOuterSensor; break;
      default: continue;
      }
      if (done) {
	AliFMDDebug(20, ("Already has all sensor volumes for ring %c",ringid));
	continue;
      }
      // Get the copy (module) number, and check that it hasn't
      // already been added to the container. 
      Int_t copy  = node->GetNumber();
      next.GetPath(path);
      // path.Replace("ALIC", "/ALIC_1");
      align = Form(SENSOR_FORMAT, fId, thisHalf, ringid, copy);
      
      switch (ringid) {
      case 'I': iInnerSensor++; break;
      case 'O': iOuterSensor++; break;
      }
    }
    if (!align.IsNull() && !path.IsNull()) {
      AliFMDDebug(20, ("Got %s -> %s", path.Data(), align.Data()));
      TGeoPNEntry* entry = 
	gGeoManager->SetAlignableEntry(align.Data(),path.Data());
      if(!entry)
	AliFatal(Form("Alignable entry %s not created. "
		      "Volume path %s not valid", 
			align.Data(),path.Data()));
#ifdef MAKE_ALIGNABLE_PHYSICAL
      TGeoPhysicalNode* phys = gGeoManager->MakeAlignablePN(entry);
      if (!phys) 
	AliWarning(Form("Physical node entry %s not created. "
			"Volume path %s not valid", 
			align.Data(),path.Data()));
#endif
      align = "";
    }
    AliFMDDebug(20, ("FMD%d: top: %d bottom: %d Inner: %d/%d Outer %d/%d", 
		      fId, hasTop, hasBottom, iInnerSensor,  nInnerSensor, 
		      iOuterSensor, nOuterSensor));
  }
}

  

//____________________________________________________________________
AliFMDRing*
AliFMDDetector::GetRing(Char_t id) const
{
  // Get the specified ring 
  // 
  //   ID      Id of ring ('I' or 'O')
  // 
  switch (id) {
  case 'i':
  case 'I': return GetInner();
  case 'o':
  case 'O': return GetOuter();
  }
  return 0;
}

//____________________________________________________________________
Double_t
AliFMDDetector::GetRingZ(Char_t id) const
{
  // Get the z-coordinate specified ring 
  // 
  //   ID      Id of ring ('I' or 'O')
  // 
  switch (id) {
  case 'i':
  case 'I': return GetInnerZ();
  case 'o':
  case 'O': return GetOuterZ();
  }
  return 0;
}

//____________________________________________________________________
TGeoMatrix*
AliFMDDetector::FindTransform(Char_t ring, UShort_t sector) const 
{
  // Find the transformation that corresponds to sector sector in ring
  // ring. 
  TObjArray* matricies = 0;
  switch (ring) {
  case 'i': case 'I': matricies = fInnerTransforms; break;
  case 'o': case 'O': matricies = fOuterTransforms; break;
  }
  if (!matricies) { 
    AliWarning(Form("Unknown ring %c of FMD%d", ring, fId));
    return 0;
  }
  UInt_t module = sector / 2;
  TGeoMatrix* m = static_cast<TGeoMatrix*>(matricies->At(module));
  if (!m) {
    AliWarning(Form("No matrix found for sector %d in FMD%d%c", 
		    sector, fId, ring));
    return 0;
  }
  return m;
}

  
//____________________________________________________________________
void
AliFMDDetector::Detector2XYZ(Char_t   ring, 
			     UShort_t sector,
			     UShort_t strip, 
			     Double_t& x, 
			     Double_t& y, 
			     Double_t& z) const
{
  // Translate detector coordinates (this,ring,sector,strip) into
  // (x,y,z) coordinates (in global reference frame)
  AliFMDRing* r = GetRing(ring);
  if (!r) { 
    AliWarning(Form("No such ring FMD%d%c ", fId, ring));
    return;
  }
  TGeoMatrix* m = FindTransform(ring, sector);
  if (!m) { 
    AliWarning(Form("No transfrmation found for FMD%d%c[%02d]", 
		    fId, ring, sector));
    return;
  }
  Double_t rho      = r->GetStripRadius(strip);
  Double_t phi      = ((sector % 2) - .5) * r->GetTheta();
  Double_t siThick  = r->GetSiThickness();
#if 0 
  Double_t modThick = (siThick
		       + r->GetPrintboardThickness()
		       + r->GetCopperThickness()
		       + r->GetChipThickness()
		       + r->GetSpacing());
#endif
  AliFMDDebug(30, ("Rho %7.3f, angle %7.3f", rho, phi));
  Double_t local[]  = { rho * TMath::Cos(phi * TMath::DegToRad()), 
		        rho * TMath::Sin(phi * TMath::DegToRad()), 
		        /* -modThick + */ siThick / 2 };
  Double_t master[3];
  AliFMDDebug(30, ("Local (%7.3f,%7.3f,%7.3f)",local[0], local[1], local[2]));
  m->LocalToMaster(local, master);
  AliFMDDebug(30, ("Master (%7.3f,%7.3f,%7.3f)",
		    master[0],master[1],master[2]));
  x = master[0];
  y = master[1];
  z = master[2];
}

//____________________________________________________________________
Bool_t
AliFMDDetector::XYZ2Detector(Double_t  x,
			     Double_t  y,
			     Double_t  z,
			     Char_t&   ring, 
			     UShort_t& sector,
			     UShort_t& strip) const
{
  // Translate (x,y,z) coordinates (in global reference frame) into 
  // detector coordinates (this,ring,sector,strip).
  AliFMDRing* rng = 0;
  ring = -1;
  for (int j = 0; j < 2; j++) {
    rng = GetRing(j == 0 ? 'I'  : 'O');
    if (!rng) continue;
    Double_t ringZ    = GetRingZ(j == 0 ? 'I'  : 'O');
    Double_t modSpace = TMath::Sign(rng->GetModuleSpacing(), ringZ);
    if (TMath::Abs(z - ringZ) < 0.01 || 
	TMath::Abs(z - ringZ + modSpace) < 0.01) break;
    rng = 0;
  }
  if (rng && rng->XYZ2Detector(x, y, z - GetRingZ(rng->GetId()),
			       sector, strip)) {
    ring = rng->GetId();
    return kTRUE;
  }
  return kFALSE;
}

  

//____________________________________________________________________
// 
// EOF
//
Commit	Line	Data
1a1fdef7	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	**************************************************************************/
1a1fdef7	15	/* $Id$ */
c2fc1258	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
02a27b50	20	@ingroup FMD_base
c2fc1258	21	*/
1a1fdef7	22
	23	//____________________________________________________________________
	24	//
6169f936	25	// AliFMDDetector.
	26	//
	27	// Base class for concrete FMD detectors, like AliFMD1, AliFMD2,
	28	// AliFMD3.
1a1fdef7	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	//
090026bf	37
090026bf	38	#include <TGeoManager.h> // ROOT_TGeoManager
4445cb1c	39	#include <TGeoPhysicalNode.h> // ROOT_TGeoPhysicalNode
090026bf	40	#include <TGeoMatrix.h> // ROOT_TGeoMatrix
	41	#include <TMath.h> // ROOT_TMath
	42
1a1fdef7	43	#include "AliFMDDetector.h" // ALIFMDSUBDETECTOR_H
1a1fdef7	44	#include "AliFMDRing.h" // ALIFMDRING_H
f95a63c4	45	#include "AliFMDDebug.h" // ALIFMDDEBUG_H ALILOG_H
1a1fdef7	46
	47	//====================================================================
	48	ClassImp(AliFMDDetector)
	49	#if 0
	50	; // This is here to keep Emacs for indenting the next line
	51	#endif
	52
	53	//____________________________________________________________________
	54	AliFMDDetector::AliFMDDetector(Int_t id, AliFMDRing* inner, AliFMDRing* outer)
	55	: TNamed(Form("FMD%d", id), "Forward multiplicity ring"),
	56	fId(id),
b5ee4425	57	fInnerZ(0.),
b5ee4425	58	fOuterZ(0.),
b5ee4425	59	fInnerHoneyLowR(0.),
	60	fInnerHoneyHighR(0.),
	61	fOuterHoneyLowR(0.),
	62	fOuterHoneyHighR(0.),
1a1fdef7	63	fInner(inner),
bf000c32	64	fOuter(outer),
	65	fInnerTransforms(0),
	66	fOuterTransforms(0)
1a1fdef7	67	{
088f8e79	68	// Constructor
	69	//
	70	// ID Id of detector (1,2, or 3)
	71	// INNER Inner ring geometry
	72	// OUTER Outer ring geometry (if any)
	73	//
1a1fdef7	74	SetInnerHoneyLowR(0);
	75	SetInnerHoneyHighR(0);
	76	SetInnerZ(0);
	77	SetOuterZ(0);
	78	SetOuterHoneyLowR(0);
	79	SetOuterHoneyHighR(0);
	80	}
	81
088f8e79	82	//____________________________________________________________________
	83	AliFMDDetector::AliFMDDetector(const AliFMDDetector& other)
	84	: TNamed(other),
	85	fId(other.fId),
b5ee4425	86	fInnerZ(0.),
b5ee4425	87	fOuterZ(0.),
b5ee4425	88	fInnerHoneyLowR(0.),
	89	fInnerHoneyHighR(0.),
	90	fOuterHoneyLowR(0.),
	91	fOuterHoneyHighR(0.),
088f8e79	92	fInner(other.fInner),
bf000c32	93	fOuter(other.fOuter),
	94	fInnerTransforms(other.fInnerTransforms),
	95	fOuterTransforms(other.fOuterTransforms)
088f8e79	96	{
088f8e79	97	// Copy constructor
088f8e79	98	SetInnerHoneyLowR(other.GetInnerHoneyLowR());
	99	SetInnerHoneyHighR(other.GetInnerHoneyHighR());
	100	SetInnerZ(other.GetInnerZ());
	101	SetOuterZ(other.GetOuterZ());
	102	SetOuterHoneyLowR(other.GetOuterHoneyLowR());
	103	SetOuterHoneyHighR(other.GetOuterHoneyHighR());
	104	}
	105
	106	//____________________________________________________________________
	107	AliFMDDetector&
	108	AliFMDDetector::operator=(const AliFMDDetector& other)
	109	{
	110	// Assignment operator
	111	SetName(other.GetName());
	112	SetTitle(other.GetTitle());
bf000c32	113	fId = other.fId;
	114	fInner = other.fInner;
	115	fOuter = other.fOuter;
	116	fInnerTransforms = other.fInnerTransforms;
	117	fOuterTransforms = other.fOuterTransforms;
088f8e79	118	SetInnerHoneyLowR(other.GetInnerHoneyLowR());
	119	SetInnerHoneyHighR(other.GetInnerHoneyHighR());
	120	SetInnerZ(other.GetInnerZ());
	121	SetOuterZ(other.GetOuterZ());
	122	SetOuterHoneyLowR(other.GetOuterHoneyLowR());
	123	SetOuterHoneyHighR(other.GetOuterHoneyHighR());
	124	return *this;
	125	}
	126
1a1fdef7	127	//____________________________________________________________________
	128	void
	129	AliFMDDetector::Init()
	130	{
088f8e79	131	// Initialize.
1a1fdef7	132	if (fInner) {
	133	SetInnerHoneyLowR(fInner->GetLowR() + 1.);
	134	SetInnerHoneyHighR(fInner->GetHighR() + 1.);
	135	}
	136	if (fOuter) {
	137	SetOuterHoneyLowR(fOuter->GetLowR() + 1.);
	138	SetOuterHoneyHighR(fOuter->GetHighR() + 1.);
bf000c32	139	}
	140	}
	141
	142	//____________________________________________________________________
	143	Bool_t
	144	AliFMDDetector::HasAllTransforms(Char_t ring) const
	145	{
02a27b50	146	// Check if we got all transformations for a given ring. Return
02a27b50	147	// true in that case.
bf000c32	148	AliFMDRing* r = GetRing(ring);
	149	if (!r) return kTRUE;
	150	TObjArray* matricies = (r == fInner ? fInnerTransforms : fOuterTransforms);
	151	if (!matricies) return kTRUE;
	152	if (matricies->GetEntries() == r->GetNModules()) return kTRUE;
	153	return kFALSE;
	154	}
	155
	156	#define IS_NODE_THIS(name) \
	157	(name[0] == 'F' && name[2] == 'M' && name[1] == Char_t(48+fId) && \
	158	(name[3] == 'T' \|\| name[3] == 'B'))
d98fbfa5	159	#define IS_NODE_SENSOR(name) \
d98fbfa5	160	(name[0] == 'F' && (name[2] == 'B' \|\| name[2] == 'F') && name[3] == 'H')
458e52e8	161	//#define IS_NODE_SENSOR(name)
d98fbfa5	162	// (name[0] == 'F' && name[2] == 'S' && name[3] == 'E')
9de78b35	163	#define IS_NODE_HALF(name) \
9de78b35	164	(name[0] == 'F' && name[2] == 'M' && (name[3] == 'B' \|\| name[3] == 'T'))
4445cb1c	165	#define HALF_FORMAT "FMD/FMD%d_%c"
4445cb1c	166	#define SENSOR_FORMAT "FMD/FMD%d_%c/FMD%c_%02d"
bf000c32	167
	168	//____________________________________________________________________
	169	void
	170	AliFMDDetector::InitTransformations()
	171	{
02a27b50	172	// Find all local<->global transformations for this detector.
bf000c32	173	if ((!fInner \|\| (fInner && fInnerTransforms)) &&
bf000c32	174	(!fOuter \|\| (fOuter && fOuterTransforms))) {
f95a63c4	175	AliFMDDebug(5, ("Transforms for FMD%d already registered", fId));
bf000c32	176	return;
bf000c32	177	}
f95a63c4	178	AliFMDDebug(5, ("Initializing transforms for FMD%d", fId));
bf000c32	179	if (!gGeoManager) {
	180	AliFatal("No TGeoManager defined");
	181	return;
	182	}
4445cb1c	183
4445cb1c	184	// Implementation using alignable volume names.
bf000c32	185	// Make container of transforms
	186	if (fInner && !fInnerTransforms)
	187	fInnerTransforms = new TObjArray(fInner->GetNModules());
	188	if (fOuter && !fOuterTransforms)
	189	fOuterTransforms = new TObjArray(fOuter->GetNModules());
	190
b2e6f0b0	191	// Loop over bottom/top
	192	for (size_t ihalf = 0; ihalf < 2; ihalf++) {
	193	char half = (ihalf == 0 ? 'T' : 'B');
	194	TString path(Form(HALF_FORMAT, fId, half));
	195	TGeoPNEntry* entry = gGeoManager->GetAlignableEntry(path.Data());
	196	if (!entry) {
	197	AliError(Form("Alignable entry for half-detector \"%s\" not found!",
	198	path.Data()));
	199	continue;
	200	}
	201	TGeoPhysicalNode* pn = entry->GetPhysicalNode();
	202	if (!pn) {
	203	AliWarning(Form("Making physical volume for \"%s\"", path.Data()));
	204	pn = gGeoManager->MakeAlignablePN(entry);
	205	if (!pn) {
	206	AliError(Form("No physical node for \"%s\"", path.Data()));
	207	continue;
	208	}
	209	}
	210	}
	211
4445cb1c	212	// Loop over rings
	213	for (size_t iring = 0; iring < 2; iring++) {
	214	char ring = (iring == 0 ? 'I' : 'O');
	215	TObjArray* trans = 0;
	216	AliFMDRing* r = 0;
	217	switch (ring) {
	218	case 'I': r = fInner; trans = fInnerTransforms; break;
	219	case 'O': r = fOuter; trans = fOuterTransforms; break;
	220	}
	221	if (!r \|\| !trans) continue;
	222
	223	Int_t nModules = r->GetNModules();
	224	if (nModules <= 0) continue;
	225
	226	// Loop over bottom/top
	227	for (size_t ihalf = 0; ihalf < 2; ihalf++) {
	228	char half = (ihalf == 0 ? 'T' : 'B');
	229	Int_t base = (half == 'T' ? 0 : nModules / 2);
	230
	231	// Loop over modules in this half ring
	232	for (Int_t imod = 0; imod < nModules / 2; imod++) {
	233	// Find physical node entry
	234	TString path(Form(SENSOR_FORMAT, fId, half, ring, base+imod));
	235	TGeoPNEntry* entry = gGeoManager->GetAlignableEntry(path.Data());
	236	if (!entry) {
	237	AliError(Form("Alignable entry for sensor \"%s\" not found!",
	238	path.Data()));
	239	continue;
	240	}
	241	TGeoPhysicalNode* pn = entry->GetPhysicalNode();
	242	if (!pn) {
	243	AliWarning(Form("Making physical volume for \"%s\"", path.Data()));
	244	pn = gGeoManager->MakeAlignablePN(entry);
	245	if (!pn) {
	246	AliError(Form("No physical node for \"%s\"", path.Data()));
	247	continue;
	248	}
	249	}
	250
	251	const TGeoMatrix* pm = pn->GetMatrix();
	252	if (!pm) {
	253	AliError(Form("No matrix for path \"%s\"", path.Data()));
	254	continue;
	255	}
	256	// Get transformation matrix for this node, and store it.
	257	TGeoMatrix* t = new TGeoHMatrix(*pm);
	258	trans->AddAt(t, base+imod);
42f1b2f5	259	AliFMDDebug(5, ("Found matrix for path \"%s\": %p",path.Data(),pm));
4445cb1c	260	}
	261	}
	262	}
	263	if (HasAllTransforms('I') && HasAllTransforms('O')) return;
	264
	265	// Alternative implementation using TGeoIter.
	266	TGeoVolume* topVolume = gGeoManager->GetTopVolume();
	267	if (!topVolume) {
	268	AliFatal("No top-level volume defined");
	269	return;
	270	}
bf000c32	271	// Make an iterator
	272	TGeoIterator next(topVolume);
	273	TGeoNode* node = 0;
	274
	275	// Find the node corresponding to this detector, and then find the
	276	// sensor volumes
	277	Bool_t thisNodeFound = kFALSE;
	278	Bool_t allInners = HasAllTransforms('I');
	279	Bool_t allOuters = HasAllTransforms('O');
	280
	281	while ((node = static_cast<TGeoNode*>(next()))
	282	&& !(allInners && allOuters)) {
	283	// Get nodes names
	284	const Char_t* name = node->GetName();
	285	if (!name) continue;
f95a63c4	286	AliFMDDebug(50, ("Got volume %s", name));
bf000c32	287	// Check if this node is this detector
	288	// The base offset for numbers in the ASCII table is 48
	289	if (IS_NODE_THIS(name)) {
f95a63c4	290	AliFMDDebug(20, ("Found detector node '%s' for FMD%d", name, fId));
bf000c32	291	thisNodeFound = kTRUE;
	292	}
	293	// if the detector was found, then we're on that branch, and we
	294	// check if this node represents a module in that branch.
	295	if (thisNodeFound && IS_NODE_SENSOR(name)) {
f95a63c4	296	AliFMDDebug(20, ("Found sensor node '%s' for FMD%d", name, fId));
bf000c32	297	// Get the ring Id.
	298	Char_t ringid = name[1];
	299
	300	// Get the approprate ring
	301	AliFMDRing* ring = GetRing(ringid);
	302	if (!ring) continue;
	303
	304	// Check whether we have all the modules we need for this ring,
	305	// and if so, go on to the next node.
	306	Bool_t& done = (ring == fInner ? allInners : allOuters);
	307	if ((done = HasAllTransforms(ringid))) {
f95a63c4	308	AliFMDDebug(20, ("Already has all module transforms for ring %c",
bf000c32	309	ringid));
	310	continue;
	311	}
	312
	313	// Get the approprate container
	314	TObjArray* matricies = (ringid == 'i' \|\| ringid == 'I'
	315	? fInnerTransforms : fOuterTransforms);
	316
	317	// Get the copy (module) number, and check that it hasn't
	318	// already been added to the container.
	319	Int_t copy = node->GetNumber();
	320	if (matricies->At(copy)) {
	321	AliWarning(Form("Have a transformation for module %d in ring %c",
	322	copy, ringid));
	323	continue;
	324	}
	325
	326	// Get the global transformation matrix, and store it.
	327	TGeoMatrix* trans = new TGeoHMatrix(*(next.GetCurrentMatrix()));
	328	matricies->AddAt(trans, copy);
	329
	330	}
1a1fdef7	331	}
1a1fdef7	332	}
1a1fdef7	333
9de78b35	334	//____________________________________________________________________
	335	void
	336	AliFMDDetector::SetAlignableVolumes() const
	337	{
97e94238	338	// Set alignable volumes.
	339	// This will define the alignable volumes.
	340	// That is currently, the modules and the half-rings.
	341
f95a63c4	342	AliFMDDebug(10, ("Making alignable volumes for FMD%d", fId));
9de78b35	343	if (!gGeoManager) {
	344	AliFatal("No TGeoManager defined");
	345	return;
	346	}
	347	TGeoVolume* topVolume = gGeoManager->GetTopVolume();
	348	if (!topVolume) {
	349	AliFatal("No top-level volume defined");
	350	return;
	351	}
	352
	353	// Make an iterator
	354	TGeoIterator next(topVolume);
	355	next.Reset(topVolume);
	356	next.SetTopName(Form("/%s_1", topVolume->GetName()));
	357	TGeoNode* node = 0;
	358
	359	Int_t nInnerSensor = (fInner ? fInner->GetNModules() : 0);
	360	Int_t nOuterSensor = (fOuter ? fOuter->GetNModules() : 0);
	361	// Find the node corresponding to this detector, and then find the
	362	// sensor volumes
	363	Bool_t thisNodeFound = kFALSE;
	364	Char_t thisHalf = '\0';
	365	Int_t iInnerSensor = 0;
	366	Int_t iOuterSensor = 0;
	367	Bool_t hasTop = false;
	368	Bool_t hasBottom = false;
	369
	370	TString path, align;
	371	while ((node = static_cast<TGeoNode*>(next()))
	372	&& (iInnerSensor < nInnerSensor \|\| iOuterSensor < nOuterSensor
	373	\|\| !hasBottom \|\| !hasTop)) {
	374	// Get nodes names
	375	const Char_t* name = node->GetName();
	376	if (!name) continue;
f95a63c4	377	AliFMDDebug((name[0] == 'F' ? 40 : 50), ("Got volume %s", name));
9de78b35	378	// Check if this node is this detector
	379	// The base offset for numbers in the ASCII table is 48
	380	if (IS_NODE_THIS(name)) {
f95a63c4	381	AliFMDDebug(20, ("Found detector node '%s' for FMD%d", name, fId));
9de78b35	382	thisNodeFound = kTRUE;
	383	}
	384
	385	// if a half ring is found, then we're on that branch, and we
	386	// check if this node represents a half ring on that branch
	387	if (thisNodeFound && IS_NODE_HALF(name)) {
f95a63c4	388	AliFMDDebug(30, ("Found half node '%s' for FMD%d", name, fId));
9de78b35	389	// Get the half Id.
	390	thisHalf = name[3];
	391
	392	// Check if we're done
	393	Bool_t done = (thisHalf == 'T' ? hasTop : hasBottom);
	394	if (done) {
f95a63c4	395	AliFMDDebug(20, ("Already has all halves for detector %c",name[1]));
9de78b35	396	continue;
	397	}
	398
	399	switch (thisHalf) {
	400	case 'T': hasTop = true; break;
	401	case 'B': hasBottom = true; break;
	402	default:
a3b4090c	403	AliWarning(Form("Unknown part '%c' of FMD%d", thisHalf, fId));
9de78b35	404	continue; // because the node is unknown.
	405	}
	406
	407	// Get the node path
	408	next.GetPath(path);
4445cb1c	409	align = Form(HALF_FORMAT, fId, thisHalf);
9de78b35	410	}
	411
	412	// if the detector was found, then we're on that branch, and we
	413	// check if this node represents a module in that branch.
	414	if (thisNodeFound && thisHalf && IS_NODE_SENSOR(name)) {
f95a63c4	415	AliFMDDebug(30, ("Found sensor node '%s' for FMD%d", name, fId));
9de78b35	416	// Get the ring Id.
	417	Char_t ringid = name[1];
	418
	419	// check that the ring is valid
	420	if (!GetRing(ringid)) {
	421	AliWarning(Form("Invalid ring %c for FMD%d", ringid, fId));
	422	continue;
	423	}
	424
	425	// Check if we're done
	426	Bool_t done = false;
	427	switch (ringid) {
	428	case 'I': done = iInnerSensor >= nInnerSensor; break;
	429	case 'O': done = iOuterSensor >= nOuterSensor; break;
	430	default: continue;
	431	}
	432	if (done) {
f95a63c4	433	AliFMDDebug(20, ("Already has all sensor volumes for ring %c",ringid));
9de78b35	434	continue;
	435	}
	436	// Get the copy (module) number, and check that it hasn't
	437	// already been added to the container.
	438	Int_t copy = node->GetNumber();
	439	next.GetPath(path);
	440	// path.Replace("ALIC", "/ALIC_1");
4445cb1c	441	align = Form(SENSOR_FORMAT, fId, thisHalf, ringid, copy);
9de78b35	442
	443	switch (ringid) {
	444	case 'I': iInnerSensor++; break;
	445	case 'O': iOuterSensor++; break;
	446	}
	447	}
	448	if (!align.IsNull() && !path.IsNull()) {
f95a63c4	449	AliFMDDebug(20, ("Got %s -> %s", path.Data(), align.Data()));
9de78b35	450	TGeoPNEntry* entry =
	451	gGeoManager->SetAlignableEntry(align.Data(),path.Data());
	452	if(!entry)
	453	AliFatal(Form("Alignable entry %s not created. "
	454	"Volume path %s not valid",
	455	align.Data(),path.Data()));
	456	#ifdef MAKE_ALIGNABLE_PHYSICAL
	457	TGeoPhysicalNode* phys = gGeoManager->MakeAlignablePN(entry);
	458	if (!phys)
	459	AliWarning(Form("Physical node entry %s not created. "
	460	"Volume path %s not valid",
	461	align.Data(),path.Data()));
	462	#endif
	463	align = "";
	464	}
f95a63c4	465	AliFMDDebug(20, ("FMD%d: top: %d bottom: %d Inner: %d/%d Outer %d/%d",
9de78b35	466	fId, hasTop, hasBottom, iInnerSensor, nInnerSensor,
	467	iOuterSensor, nOuterSensor));
	468	}
	469	}
	470
	471
	472
1a1fdef7	473	//____________________________________________________________________
	474	AliFMDRing*
	475	AliFMDDetector::GetRing(Char_t id) const
	476	{
088f8e79	477	// Get the specified ring
	478	//
	479	// ID Id of ring ('I' or 'O')
	480	//
1a1fdef7	481	switch (id) {
	482	case 'i':
	483	case 'I': return GetInner();
	484	case 'o':
	485	case 'O': return GetOuter();
	486	}
	487	return 0;
	488	}
	489
	490	//____________________________________________________________________
	491	Double_t
	492	AliFMDDetector::GetRingZ(Char_t id) const
	493	{
088f8e79	494	// Get the z-coordinate specified ring
	495	//
	496	// ID Id of ring ('I' or 'O')
	497	//
1a1fdef7	498	switch (id) {
	499	case 'i':
	500	case 'I': return GetInnerZ();
	501	case 'o':
	502	case 'O': return GetOuterZ();
	503	}
	504	return 0;
	505	}
bf000c32	506
	507	//____________________________________________________________________
	508	TGeoMatrix*
	509	AliFMDDetector::FindTransform(Char_t ring, UShort_t sector) const
	510	{
	511	// Find the transformation that corresponds to sector sector in ring
	512	// ring.
	513	TObjArray* matricies = 0;
	514	switch (ring) {
	515	case 'i': case 'I': matricies = fInnerTransforms; break;
	516	case 'o': case 'O': matricies = fOuterTransforms; break;
	517	}
	518	if (!matricies) {
	519	AliWarning(Form("Unknown ring %c of FMD%d", ring, fId));
	520	return 0;
	521	}
	522	UInt_t module = sector / 2;
	523	TGeoMatrix* m = static_cast<TGeoMatrix*>(matricies->At(module));
	524	if (!m) {
	525	AliWarning(Form("No matrix found for sector %d in FMD%d%c",
	526	sector, fId, ring));
	527	return 0;
	528	}
	529	return m;
	530	}
	531
	532
1a1fdef7	533	//____________________________________________________________________
1a1fdef7	534	void
bf000c32	535	AliFMDDetector::Detector2XYZ(Char_t ring,
1a1fdef7	536	UShort_t sector,
	537	UShort_t strip,
	538	Double_t& x,
	539	Double_t& y,
	540	Double_t& z) const
	541	{
088f8e79	542	// Translate detector coordinates (this,ring,sector,strip) into
088f8e79	543	// (x,y,z) coordinates (in global reference frame)
1a1fdef7	544	AliFMDRing* r = GetRing(ring);
f38b1653	545	if (!r) {
	546	AliWarning(Form("No such ring FMD%d%c ", fId, ring));
	547	return;
	548	}
bf000c32	549	TGeoMatrix* m = FindTransform(ring, sector);
f38b1653	550	if (!m) {
	551	AliWarning(Form("No transfrmation found for FMD%d%c[%02d]",
	552	fId, ring, sector));
	553	return;
	554	}
bf000c32	555	Double_t rho = r->GetStripRadius(strip);
	556	Double_t phi = ((sector % 2) - .5) * r->GetTheta();
	557	Double_t siThick = r->GetSiThickness();
458e52e8	558	#if 0
bf000c32	559	Double_t modThick = (siThick
	560	+ r->GetPrintboardThickness()
	561	+ r->GetCopperThickness()
	562	+ r->GetChipThickness()
	563	+ r->GetSpacing());
458e52e8	564	#endif
f95a63c4	565	AliFMDDebug(30, ("Rho %7.3f, angle %7.3f", rho, phi));
458e52e8	566	Double_t local[] = { rho * TMath::Cos(phi * TMath::DegToRad()),
458e52e8	567	rho * TMath::Sin(phi * TMath::DegToRad()),
d98fbfa5	568	/* -modThick + */ siThick / 2 };
bf000c32	569	Double_t master[3];
f95a63c4	570	AliFMDDebug(30, ("Local (%7.3f,%7.3f,%7.3f)",local[0], local[1], local[2]));
bf000c32	571	m->LocalToMaster(local, master);
f95a63c4	572	AliFMDDebug(30, ("Master (%7.3f,%7.3f,%7.3f)",
bf000c32	573	master[0],master[1],master[2]));
	574	x = master[0];
	575	y = master[1];
	576	z = master[2];
1a1fdef7	577	}
1a1fdef7	578
54e415a8	579	//____________________________________________________________________
	580	Bool_t
	581	AliFMDDetector::XYZ2Detector(Double_t x,
	582	Double_t y,
	583	Double_t z,
	584	Char_t& ring,
	585	UShort_t& sector,
	586	UShort_t& strip) const
	587	{
088f8e79	588	// Translate (x,y,z) coordinates (in global reference frame) into
088f8e79	589	// detector coordinates (this,ring,sector,strip).
54e415a8	590	AliFMDRing* rng = 0;
	591	ring = -1;
	592	for (int j = 0; j < 2; j++) {
	593	rng = GetRing(j == 0 ? 'I' : 'O');
	594	if (!rng) continue;
	595	Double_t ringZ = GetRingZ(j == 0 ? 'I' : 'O');
	596	Double_t modSpace = TMath::Sign(rng->GetModuleSpacing(), ringZ);
	597	if (TMath::Abs(z - ringZ) < 0.01 \|\|
	598	TMath::Abs(z - ringZ + modSpace) < 0.01) break;
	599	rng = 0;
	600	}
	601	if (rng && rng->XYZ2Detector(x, y, z - GetRingZ(rng->GetId()),
	602	sector, strip)) {
	603	ring = rng->GetId();
	604	return kTRUE;
	605	}
	606	return kFALSE;
	607	}
	608
	609
	610
1a1fdef7	611	//____________________________________________________________________
	612	//
	613	// EOF
	614	//