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

/**************************************************************************
 * Copyright(c) 1998-1999, 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$ */

//____________________________________________________________________
//                                                                          
// Forward Multiplicity Detector based on Silicon wafers. This class
// contains the base procedures for the Forward Multiplicity detector
// Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
// which has 1 or 2 rings of silicon sensors. 
//                                                       
// This is the base class for all FMD manager classes. 
//                    
// The actual code is done by various separate classes.   Below is
// diagram showing the relationship between the various FMD classes
// that handles the simulation
//
//      +--------+ 1     +-----------------+ 
//      | AliFMD |<>-----| AliFMDSimulator |
//      +--------+	 +-----------------+
//                               ^              
//                               |
//                 +-------------+-------------+
//                 |                           |	      
//        +--------------------+   +-------------------+
//        | AliFMDGeoSimulator |   | AliFMDG3Simulator | 
//        +--------------------+   +---------+---------+
//      
//
// *  AliFMD 
//    This defines the interface for the various parts of AliROOT that
//    uses the FMD, like AliFMDSimulator, AliFMDDigitizer, 
//    AliFMDReconstructor, and so on. 
//
// *  AliFMDSimulator
//    This is the base class for the FMD simulation tasks.   The
//    simulator tasks are responsible to implment the geoemtry, and
//    process hits. 
//                                                                          
// *  AliFMDGeoSimulator
//    This is a concrete implementation of the AliFMDSimulator that
//    uses the TGeo classes directly only.  This defines the active
//    volume as an ONLY XTRU shape with a divided MANY TUBS shape
//    inside to implement the particular shape of the silicon
//    sensors. 
//
// *  AliFMDG3Simulator
//    This is a concrete implementation of the AliFMDSimulator that
//    uses the TVirtualMC interface with GEANT 3.21-like messages.
//    This implements the active volume as a divided TUBS shape.  Hits
//    in the corners should be cut away at run time (but currently
//    isn't). 
//
#include <math.h>
#include "AliFMDG3Simulator.h"	// ALIFMDG3SIMULATOR_H
#include "AliFMDGeometry.h"	// ALIFMDGEOMETRY_H
#include "AliFMDDetector.h"	// ALIFMDDETECTOR_H
#include "AliFMDRing.h"		// ALIFMDRING_H
#include "AliFMD1.h"		// ALIFMD1_H
#include "AliFMD2.h"		// ALIFMD2_H
#include "AliFMD3.h"		// ALIFMD3_H
#include "AliFMD.h"		// ALIFMD_H
#include <AliLog.h>		// ALILOG_H
#include <TVector2.h>		// ROOT_TVector2
#include <TVirtualMC.h>		// ROOT_TVirtualMC
#include <TArrayI.h>		// ROOT_TArrayI

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

//____________________________________________________________________
AliFMDG3Simulator::AliFMDG3Simulator() 
{
  // Default constructor
  fSectorOff   = 1;
  fModuleOff   = 3;
  fRingOff     = 4;
  fDetectorOff = 5;
}

//____________________________________________________________________
AliFMDG3Simulator::AliFMDG3Simulator(AliFMD* fmd, Bool_t detailed) 
  : AliFMDSimulator(fmd, detailed)
{
  // Normal constructor
  // 
  // Parameters: 
  // 
  //      fmd		Pointer to AliFMD object 
  //      detailed      Whether to make a detailed simulation or not 
  // 
  fSectorOff   = 1;
  fModuleOff   = 3;
  fRingOff     = 4;
  fDetectorOff = 5;
}

//____________________________________________________________________
Bool_t
AliFMDG3Simulator::RingGeometry(AliFMDRing* r) 
{
  // Setup the geometry of a ring.    The defined TGeoVolume is
  // returned, and should be used when setting up the rest of the
  // volumes. 
  // 
  // Parameters:
  //
  //     r		Pointer to ring geometry object 
  // 
  // Returns:
  //    true on success 
  //
  if (!r) { 
    AliError("Didn't get a ring object");
    return kFALSE;
  }
  Char_t      id       = r->GetId();
  Double_t    siThick  = r->GetSiThickness();
  // const Int_t nv       = r->GetNVerticies();
  TVector2*   a        = r->GetVertex(5);
  TVector2*   b        = r->GetVertex(3);
  TVector2*   c        = r->GetVertex(4);
  Double_t    theta    = r->GetTheta();
  Double_t    off      = (TMath::Tan(TMath::Pi() * theta / 180) 
			  * r->GetBondingWidth());
  Double_t    rmax     = b->Mod();
  Double_t    rmin     = r->GetLowR();
  Double_t    pcbThick = r->GetPrintboardThickness();
  Double_t    modSpace = r->GetModuleSpacing();
  Double_t    legr     = r->GetLegRadius();
  Double_t    legl     = r->GetLegLength();
  Double_t    legoff   = r->GetLegOffset();
  Int_t       ns       = r->GetNStrips();
  Double_t    stripoff = a->Mod();
  Double_t    dstrip   = (rmax - stripoff) / ns;
  Double_t    par[10];
  TString     name;
  TString     name2;
  TVirtualMC* mc       = TVirtualMC::GetMC();
  
  Int_t siId = fFMD->GetIdtmed()->At(kSiId);
  Int_t airId = fFMD->GetIdtmed()->At(kAirId);
  Int_t pcbId = fFMD->GetIdtmed()->At(kPcbId);
  Int_t plaId = fFMD->GetIdtmed()->At(kPlasticId);

  // Virtual volume shape to divide - This volume is only defined if
  // the geometry is set to be detailed. 
  // Ring mother volume 
  par[0]     =  rmin;
  par[1]     =  rmax;
  par[2]     =  (siThick + pcbThick + legl + modSpace) / 2;
  name       =  Form(fgkRingName, id);
  mc->Gsvolu(name.Data(), "TUBE", airId, par, 3);

  par[0] = rmin;
  par[1] = rmax;
  par[2] = siThick / 2;
  par[3] = -theta;
  par[4] = theta;
  name   = Form(fgkActiveName, id);
  mc->Gsvolu(name.Data(), "TUBS", (fDetailed ? airId : siId), par, 5);

  Int_t sid = -1;
  if (fDetailed) {
    name2 = name;
    name  = Form(fgkSectorName, id);
    mc->Gsdvn2(name.Data(), name2.Data(), 2, 2, -theta, airId);
    
    name2 = name;
    name  = Form(fgkStripName, id);
    mc->Gsdvt2(name.Data(), name2.Data(), dstrip, 1, stripoff, siId, ns);
    sid = mc->VolId(name.Data());
    AliDebug(10, Form("Got volume id %d for volume %s", sid, name.Data()));
  }
  
  switch (id) {
  case 'i':
  case 'I':
    fInnerId = sid;
    // fInnerV  = moduleVolume->GetNumber();
    break;
  case 'o':
  case 'O':
    fOuterId = sid;
    // fOuterV  = moduleVolume->GetNumber();
    break;
  }

  // Shape of Printed circuit Board 
  // Top
  par[0] = c->Y() - off;
  par[1] = b->Y() - off;
  par[2] = pcbThick / 2;
  par[3] = (b->X() - c->X()) / 2;
  par[4] = off;
  name   = Form(fgkPCBName, id, 'T');
  mc->Gsvolu(name.Data(), "TRD1", pcbId, par, 4);
  // Bottom
  par[0] = a->Y() - off;
  par[1] = c->Y() - off;
  par[3] = (c->X() - a->X()) / 2;
  name   = Form(fgkPCBName, id, 'B');
  mc->Gsvolu(name.Data(), "TRD1", pcbId, par, 4);

  // Short leg volume 
  par[0] = legr - .1;
  par[1] = legr;
  par[2] = legl / 2;
  name   = Form(fgkShortLegName, id);
  mc->Gsvolu(name.Data(),  "TUBE",  plaId, par, 3);
  
  // Long leg volume 
  par[2] += modSpace / 2;
  name   = Form(fgkLongLegName, id);
  mc->Gsvolu(name.Data(),  "TUBE",  plaId, par, 3);
  
  // Back container volume 
  par[0] = rmin;
  par[1] = rmax;
  par[2] = (siThick + pcbThick + legl) / 2;
  par[3] = -theta;
  par[4] = +theta;
  name   = Form(fgkBackVName, id);
  mc->Gsvolu(name.Data(), "TUBS", airId, par, 5);
  
  Double_t x = 0;
  Double_t y = 0;
  Double_t z = - par[2] + siThick / 2;
  name2      = name;
  name       = Form(fgkActiveName, id);
  mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, 0, "ONLY");
  
  Double_t pbTopL = (b->X() - c->X());
  Double_t pbBotL = (c->X() - a->X());
  Int_t    pbRot;
  mc->Matrix(pbRot, 90, 90, 0, 90, 90, 0);  

  x          =  rmin + pbBotL + pbTopL / 2;
  z          += siThick / 2 + pcbThick / 2;
  name       =  Form(fgkPCBName, id, 'T');
  mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, pbRot, "ONLY");
  
  x          =  rmin + pbBotL / 2;
  name       =  Form(fgkPCBName, id, 'B');
  mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, pbRot, "ONLY");

  x          =  a->X() + legoff + legr;
  y          =  0;
  z          += pcbThick / 2 + legl / 2;
  name       =  Form(fgkShortLegName, id);
  mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, 0, "ONLY");

  x          =  c->X();
  y          =  c->Y() - legoff - legr - off;
  mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, 0, "ONLY");

  y          =  -y;
  mc->Gspos(name.Data(), 2, name2.Data(), x, y, z, 0, "ONLY");


  // Front container volume 
  par[2]     += modSpace / 2;
  name       =  Form(fgkFrontVName, id);
  mc->Gsvolu(name.Data(), "TUBS", airId, par, 5);
  
  x          =  0;
  y          =  0;
  z          =  - par[2] + siThick / 2;
  name2      =  name;
  name       =  Form(fgkActiveName, id);
  mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, 0, "ONLY");
  
  pbTopL     =  (b->X() - c->X());
  pbBotL     =  (c->X() - a->X());
  x          =  rmin + pbBotL + pbTopL / 2;
  z          += siThick / 2 + pcbThick / 2;
  name       =  Form(fgkPCBName, id, 'T');
  mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, pbRot, "ONLY");
  
  x          =  rmin + pbBotL / 2;
  name       =  Form(fgkPCBName, id, 'B');
  mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, pbRot, "ONLY");

  x          =  a->X() + legoff + legr;
  y          =  0;
  z          += pcbThick / 2 + legl / 2 + modSpace / 2;
  name       =  Form(fgkLongLegName, id);
  mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, 0, "ONLY");

  x          =  c->X();
  y          =  c->Y() - legoff - legr - off;
  mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, 0, "ONLY");

  y          =  -y;
  mc->Gspos(name.Data(), 2, name2.Data(), x, y, z, 0, "ONLY");


  Int_t nmod = r->GetNModules();
  name2      =  Form(fgkRingName, id);
  AliDebug(10, Form("making %d modules in ring %c", nmod, id));
  for (Int_t i = 0; i < nmod; i++) {
    Double_t th      = (i + .5) * 2 * theta;
    Bool_t   isFront = (i % 2 == 0);
    name             = (isFront ? Form(fgkFrontVName,id) : 
			Form(fgkBackVName,id));
    Double_t z       = (isFront ? 0 : modSpace) / 2;
    Int_t    rot;
    mc->Matrix(rot, 90, th, 90, fmod(90 + th, 360), 0, 0);
    mc->Gspos(name.Data(), i, name2.Data(), 0, 0, z, rot, "ONLY");
  }

  return kTRUE;
}

//____________________________________________________________________
Bool_t
AliFMDG3Simulator::DetectorGeometry(AliFMDDetector* d, Double_t zmother) 
{
  // Common stuff for setting up the FMD1, FMD2, and FMD3 geometries.
  // This includes putting the Honeycomb support plates and the rings
  // into the mother volumes.   
  // 
  // Parameeters:
  //	d	  The detector geometry to use 
  //    zmother	  The midpoint in global coordinates of detector vol.
  //
  // Returns:
  //    true on success
  // 
  if (!d) return kFALSE;

  TString     name;
  TString     name2;
  TVirtualMC* mc       = TVirtualMC::GetMC();

  // Loop over the defined rings 
  for (int i = 0; i < 2; i++) {
    AliFMDRing* r     = 0;
    Double_t    lowr  = 0;
    Double_t    highr = 0;
    Double_t    rz    = 0;
    switch (i) {
    case 0: 
      r      = d->GetInner();
      lowr   = d->GetInnerHoneyLowR();
      highr  = d->GetInnerHoneyHighR();
      rz     = d->GetInnerZ();
      break;
    case 1: 
      r      = d->GetOuter();
      lowr   = d->GetOuterHoneyLowR();
      highr  = d->GetOuterHoneyHighR();
      rz     = d->GetOuterZ();
      break;
    }
    if (!r) continue;
    Char_t   c       = r->GetId();
    Int_t    id      = d->GetId();
    Int_t    airId   = (fFMD->GetIdtmed()->At(kAirId));
    Int_t    alId    = (fFMD->GetIdtmed()->At(kAlId));
    Double_t hcThick = d->GetHoneycombThickness();
    Double_t alThick = d->GetAlThickness();
    Double_t par[10];
    Double_t z;
    // Place ring in mother volume
    if (zmother > 0) z = rz - zmother + r->GetRingDepth() / 2;
    else             z = zmother - rz + r->GetRingDepth() / 2;
    name  = Form(fgkRingName, c);
    name2 = d->GetName();
    mc->Gspos(name.Data(), Int_t(c), name2.Data(), 0, 0, z, 0, "ONLY");
    
    // Place Top Honeycomb in mother volume 
    z += + r->GetRingDepth() / 2 + hcThick / 2;
    // Top of Honeycomb
    par[0] = lowr;
    par[1] = highr;
    par[2] = hcThick / 2;
    par[3] = 0;
    par[4] = 180;
    name   = Form(fgkTopHCName, id, c);
    mc->Gsvolu(name.Data(), "TUBS", alId, par, 5);
    mc->Gspos(name.Data(), 0, name2.Data(), 0, 0, z, 0, "ONLY");

    par[0] += alThick;
    par[1] -= alThick;
    par[2] -= alThick / 2;
    name2  =  name;
    name   =  Form(fgkTopIHCName, id, c);
    mc->Gsvolu(name.Data(), "TUBS", airId, par, 5);
    mc->Gspos(name.Data(), 0, name2.Data(), 0, 0, 0, 0, "ONLY");
    
    // Bot of Honeycomb
    par[0] = lowr;
    par[1] = highr;
    par[2] = hcThick / 2;
    par[3] = 180;
    par[4] = 360;
    name2  = d->GetName();
    name   = Form(fgkBotHCName, id, c);
    mc->Gsvolu(name.Data(), "TUBS", alId, par, 5);
    mc->Gspos(name.Data(), 0, name2.Data(), 0, 0, z, 0, "ONLY");

    par[0] += alThick;
    par[1] -= alThick;
    par[2] -= alThick / 2;
    name2  =  name;
    name   =  Form(fgkBotIHCName, id, c);
    mc->Gsvolu(name.Data(), "TUBS", airId, par, 5);
    mc->Gspos(name.Data(), 0, name2.Data(), 0, 0, 0, 0, "ONLY");
  }
  return kTRUE;
}

//____________________________________________________________________
Bool_t
AliFMDG3Simulator::FMD1Geometry(AliFMD1* fmd1) 
{
  // Setup the FMD1 geometry.  The FMD1 only has one ring, and no
  // special support as it is at the momement. 
  // 
  // See also AliFMDG3Simulator::DetectorGeometry 
  // 
  if (!fmd1) return kFALSE;
  Double_t rmin    = fmd1->GetInner()->GetLowR();
  Double_t rmax    = fmd1->GetInnerHoneyHighR();
  Double_t hcThick = fmd1->GetHoneycombThickness();
  Double_t w       = fmd1->GetInner()->GetRingDepth() + hcThick;
  Double_t z       = fmd1->GetInnerZ() + w / 2;
  TVirtualMC* mc   = TVirtualMC::GetMC();
  Int_t    airId   = (fFMD->GetIdtmed()->At(kAirId));

  Double_t par[3];
  par[0] = rmin;
  par[1] = rmax;
  par[2] = w / 2;
  mc->Gsvolu(fmd1->GetName(), "TUBE", airId, par, 3);
  mc->Gspos(fmd1->GetName(), fmd1->GetId(), "ALIC", 0, 0, z, 0, "ONLY");

  return DetectorGeometry(fmd1, z);
}

//____________________________________________________________________
Bool_t
AliFMDG3Simulator::FMD2Geometry(AliFMD2* fmd2) 
{
  // Setup the FMD2 geometry.  The FMD2 has no
  // special support as it is at the momement. 
  // 
  // See also AliFMDG3Simulator::DetectorGeometry 
  // 
  if (!fmd2) return kFALSE;
  Double_t rmin     = fmd2->GetInner()->GetLowR();
  Double_t rmax     = fmd2->GetOuterHoneyHighR();
  Double_t hcThick  = fmd2->GetHoneycombThickness();
  Double_t ow       = fmd2->GetInner()->GetRingDepth();
  Double_t iz       = fmd2->GetInnerZ();
  Double_t oz       = fmd2->GetOuterZ();
  Double_t w        = TMath::Abs(oz - iz) + ow + hcThick;
  Double_t z        = oz + w / 2;
  
  TVirtualMC* mc   = TVirtualMC::GetMC();
  Int_t    airId   = (fFMD->GetIdtmed()->At(kAirId));

  Double_t par[3];
  par[0] = rmin;
  par[1] = rmax;
  par[2] = w / 2;
  mc->Gsvolu(fmd2->GetName(), "TUBE", airId, par, 3);
  mc->Gspos(fmd2->GetName(), fmd2->GetId(), "ALIC", 0, 0, z, 0, "ONLY");

  return DetectorGeometry(fmd2, z);
}
  
//____________________________________________________________________
Bool_t
AliFMDG3Simulator::FMD3Geometry(AliFMD3* fmd3) 
{
  // Setup the FMD3 geometry.  The FMD2 has a rather elaborate support
  // structure, as the support will also support the vacuum
  // beam-pipe. 
  // 
  // See also AliFMDG3Simulator::DetectorGeometry 
  // 
  if (!fmd3) return kFALSE;
  Double_t nlen    = fmd3->GetNoseLength();
  Double_t nz      = fmd3->GetNoseZ();
  Double_t noser1  = fmd3->GetNoseLowR();
  Double_t noser2  = fmd3->GetNoseHighR();
  Double_t conel   = fmd3->GetConeLength();
  Double_t backl   = fmd3->GetBackLength();
  Double_t backr1  = fmd3->GetBackLowR();
  Double_t backr2  = fmd3->GetBackHighR();
  Double_t zdist   = conel -  backl - nlen;
  Double_t tdist   = backr2 - noser2;
  Double_t beaml   = TMath::Sqrt(zdist * zdist + tdist * tdist);
  Double_t theta   = -180. * TMath::ATan2(tdist, zdist) / TMath::Pi();
  Double_t innerZ  = fmd3->GetInnerZ();
  Double_t innerZh = (innerZ - fmd3->GetInner()->GetRingDepth() 
		      - fmd3->GetHoneycombThickness());
  Double_t outerZ  = fmd3->GetOuterZ();
  Double_t outerZh = (outerZ - fmd3->GetOuter()->GetRingDepth() 
		      - fmd3->GetHoneycombThickness());
  Double_t innerr1 = fmd3->GetInner()->GetLowR();
  // Double_t innerr2 = fmd3->GetInner()->GetHighR();
  Double_t outerr1 = fmd3->GetOuter()->GetLowR();
  // Double_t outerr2 = fmd3->GetOuter()->GetHighR();
  Double_t flanger = fmd3->GetFlangeR();
  Double_t minZ    = TMath::Min(nz - conel, outerZh);
  Double_t z       = fmd3->GetZ();
  Double_t zi;
  TVirtualMC* mc   = TVirtualMC::GetMC();
  Int_t    airId   = (fFMD->GetIdtmed()->At(kAirId));
  Int_t    cId     = (fFMD->GetIdtmed()->At(kCarbonId));
  Double_t par[27];
  
  // FMD3 volume 
  par[0]  = 0;
  par[1]  = 360;
  par[2]  = 8;
  // First
  par[3]  = z - nz;
  par[4]  = noser1;
  par[5]  = noser2;
  // Second
  par[6]  = z - (nz - nlen);
  par[7]  = noser1;
  par[8]  = fmd3->ConeR(z - par[6])+.15;
  // Third
  par[9]  = z - innerZ;
  par[10] = innerr1;
  par[11] = fmd3->ConeR(z - par[9])+.15;
  // Fourth
  par[12] = z - innerZh;
  par[13] = innerr1;
  par[14] = fmd3->ConeR(z - par[12])+.15;
  // Fifth
  par[15] = par[12];
  par[16] = outerr1;
  par[17] = fmd3->ConeR(z - par[15])+.15;
  // Sixth
  par[18] = z - nz + zdist + nlen;
  par[19] = outerr1;
  par[20] = fmd3->ConeR(z - par[18])+.15;
  // Seventh
  par[21] = z - nz + nlen + zdist;
  par[22] = outerr1;
  par[23] = flanger+1.5;
  // Eight
  par[24] = z - minZ;
  par[25] = outerr1;
  par[26] = flanger+1.5;
  mc->Gsvolu(fmd3->GetName(), "PCON", airId, par, 27);
  
  Int_t id;
  mc->Matrix(id, 270, 180, 90, 90, 180, 0);
  mc->Gspos(fmd3->GetName(), fmd3->GetId(), "ALIC", 0, 0, z, id, "ONLY");
  
  // Nose volume 
  par[0] = noser1;
  par[1] = noser2;
  par[2] = nlen / 2;
  zi = z - nz + nlen / 2;
  mc->Gsvolu(fgkNoseName, "TUBE", cId, par, 3);
  mc->Gspos(fgkNoseName, 0, fmd3->GetName(), 0, 0, zi, 0, "MANY");
  
  // Back
  par[0] = backr1;
  par[1] = backr2;
  par[2] = backl / 2;
  zi = z - nz + conel - backl / 2;
  mc->Gsvolu(fgkBackName, "TUBE", cId, par, 3);
  mc->Gspos(fgkBackName, 0, fmd3->GetName(), 0, 0, zi, 0, "ONLY");
  
  Int_t n;
  Double_t r;
  // The flanges 
  par[0] = (flanger - backr2) / 2;
  par[1] = fmd3->GetBeamWidth() / 2;
  par[2] = backl / 2;
  mc->Gsvolu(fgkFlangeName, "BOX", cId, par, 3);
  n = fmd3->GetNFlange();
  r = backr2 + (flanger - backr2) / 2;
  for (Int_t i = 0; i  < n; i++) {
    Double_t phi = 360. / n * i + 180. / n;
    Double_t x   = r * TMath::Cos(TMath::Pi() / 180 * phi);
    Double_t y   = r * TMath::Sin(TMath::Pi() / 180 * phi);
    Int_t    id;
    mc->Matrix(id, 90, phi, 90, 90 + phi, 0, 0);
    mc->Gspos(fgkFlangeName, i, fmd3->GetName(), x, y, zi, id, "ONLY");
  }

  // The Beams 
  par[0] = fmd3->GetBeamThickness() / 2;
  par[1] = fmd3->GetBeamWidth() / 2;	
  par[2] = beaml / 2;		   
  mc->Gsvolu(fgkBeamName, "BOX", cId, par, 3);
  n      = fmd3->GetNBeam();
  r      = noser2 + tdist / 2;
  zi     = z - nz + nlen + zdist / 2;
  for (Int_t i = 0; i  < n; i++) {
    Double_t phi = 360. / n * i;
    Double_t x   = r * TMath::Cos(TMath::Pi() / 180 * phi);
    Double_t y   = r * TMath::Sin(TMath::Pi() / 180 * phi);
    Int_t    id;
    (void)theta;
    mc->Matrix(id, 90-theta, phi, 90, 90 + phi, 360 - theta, phi);
    mc->Gspos(fgkBeamName, i, fmd3->GetName(), x, y, zi, id, "MANY");
  }
  
  return DetectorGeometry(fmd3, z);
}

//____________________________________________________________________
void
AliFMDG3Simulator::DefineGeometry() 
{
  // Setup up the FMD geometry. 
  AliDebug(10, "Setting up volume");

  AliFMDGeometry* fmd   = AliFMDGeometry::Instance();
  if (!RingGeometry(fmd->GetInner())) {
    AliError("Failed to create inner ring volume");
    return;
  }
  if (!RingGeometry(fmd->GetOuter())) {
    AliError("Failed to create outer ring volume");
    return;
  }
  FMD1Geometry(fmd->GetFMD1());
  FMD2Geometry(fmd->GetFMD2());
  FMD3Geometry(fmd->GetFMD3());
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
1a1fdef7	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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
	16	/* $Id$ */
	17
	18	//____________________________________________________________________
	19	//
	20	// Forward Multiplicity Detector based on Silicon wafers. This class
	21	// contains the base procedures for the Forward Multiplicity detector
	22	// Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
	23	// which has 1 or 2 rings of silicon sensors.
	24	//
	25	// This is the base class for all FMD manager classes.
	26	//
	27	// The actual code is done by various separate classes. Below is
	28	// diagram showing the relationship between the various FMD classes
	29	// that handles the simulation
	30	//
	31	// +--------+ 1 +-----------------+
	32	// \| AliFMD \|<>-----\| AliFMDSimulator \|
	33	// +--------+ +-----------------+
	34	// ^
	35	// \|
	36	// +-------------+-------------+
	37	// \| \|
	38	// +--------------------+ +-------------------+
	39	// \| AliFMDGeoSimulator \| \| AliFMDG3Simulator \|
	40	// +--------------------+ +---------+---------+
	41	//
	42	//
	43	// * AliFMD
	44	// This defines the interface for the various parts of AliROOT that
	45	// uses the FMD, like AliFMDSimulator, AliFMDDigitizer,
	46	// AliFMDReconstructor, and so on.
	47	//
	48	// * AliFMDSimulator
	49	// This is the base class for the FMD simulation tasks. The
	50	// simulator tasks are responsible to implment the geoemtry, and
	51	// process hits.
	52	//
	53	// * AliFMDGeoSimulator
	54	// This is a concrete implementation of the AliFMDSimulator that
	55	// uses the TGeo classes directly only. This defines the active
	56	// volume as an ONLY XTRU shape with a divided MANY TUBS shape
	57	// inside to implement the particular shape of the silicon
	58	// sensors.
	59	//
	60	// * AliFMDG3Simulator
	61	// This is a concrete implementation of the AliFMDSimulator that
	62	// uses the TVirtualMC interface with GEANT 3.21-like messages.
	63	// This implements the active volume as a divided TUBS shape. Hits
	64	// in the corners should be cut away at run time (but currently
65	// isn't).
66	//
ede5852a	67	#include <math.h>
1a1fdef7	68	#include "AliFMDG3Simulator.h" // ALIFMDG3SIMULATOR_H
	69	#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
	70	#include "AliFMDDetector.h" // ALIFMDDETECTOR_H
	71	#include "AliFMDRing.h" // ALIFMDRING_H
	72	#include "AliFMD1.h" // ALIFMD1_H
	73	#include "AliFMD2.h" // ALIFMD2_H
	74	#include "AliFMD3.h" // ALIFMD3_H
	75	#include "AliFMD.h" // ALIFMD_H
	76	#include <AliLog.h> // ALILOG_H
	77	#include <TVector2.h> // ROOT_TVector2
	78	#include <TVirtualMC.h> // ROOT_TVirtualMC
	79	#include <TArrayI.h> // ROOT_TArrayI
	80
	81	//====================================================================
	82	ClassImp(AliFMDG3Simulator)
	83	#if 0
	84	; // This is here to keep Emacs for indenting the next line
	85	#endif
	86
	87	//____________________________________________________________________
	88	AliFMDG3Simulator::AliFMDG3Simulator()
	89	{
	90	// Default constructor
	91	fSectorOff = 1;
	92	fModuleOff = 3;
	93	fRingOff = 4;
	94	fDetectorOff = 5;
	95	}
	96
	97	//____________________________________________________________________
	98	AliFMDG3Simulator::AliFMDG3Simulator(AliFMD* fmd, Bool_t detailed)
	99	: AliFMDSimulator(fmd, detailed)
	100	{
	101	// Normal constructor
	102	//
	103	// Parameters:
	104	//
	105	// fmd Pointer to AliFMD object
	106	// detailed Whether to make a detailed simulation or not
	107	//
	108	fSectorOff = 1;
	109	fModuleOff = 3;
	110	fRingOff = 4;
	111	fDetectorOff = 5;
	112	}
	113
	114	//____________________________________________________________________
	115	Bool_t
	116	AliFMDG3Simulator::RingGeometry(AliFMDRing* r)
	117	{
	118	// Setup the geometry of a ring. The defined TGeoVolume is
	119	// returned, and should be used when setting up the rest of the
	120	// volumes.
	121	//
	122	// Parameters:
	123	//
	124	// r Pointer to ring geometry object
	125	//
	126	// Returns:
	127	// true on success
	128	//
	129	if (!r) {
	130	AliError("Didn't get a ring object");
	131	return kFALSE;
132	}
133	Char_t id = r->GetId();
134	Double_t siThick = r->GetSiThickness();
135	// const Int_t nv = r->GetNVerticies();
136	TVector2* a = r->GetVertex(5);
137	TVector2* b = r->GetVertex(3);
138	TVector2* c = r->GetVertex(4);
139	Double_t theta = r->GetTheta();
140	Double_t off = (TMath::Tan(TMath::Pi() * theta / 180)
141	* r->GetBondingWidth());
142	Double_t rmax = b->Mod();
143	Double_t rmin = r->GetLowR();
144	Double_t pcbThick = r->GetPrintboardThickness();
145	Double_t modSpace = r->GetModuleSpacing();
146	Double_t legr = r->GetLegRadius();
147	Double_t legl = r->GetLegLength();
148	Double_t legoff = r->GetLegOffset();
149	Int_t ns = r->GetNStrips();
150	Double_t stripoff = a->Mod();
151	Double_t dstrip = (rmax - stripoff) / ns;
152	Double_t par[10];
153	TString name;
154	TString name2;
155	TVirtualMC* mc = TVirtualMC::GetMC();
156
157	Int_t siId = fFMD->GetIdtmed()->At(kSiId);
158	Int_t airId = fFMD->GetIdtmed()->At(kAirId);
159	Int_t pcbId = fFMD->GetIdtmed()->At(kPcbId);
160	Int_t plaId = fFMD->GetIdtmed()->At(kPlasticId);
161
162	// Virtual volume shape to divide - This volume is only defined if
163	// the geometry is set to be detailed.
164	// Ring mother volume
165	par[0] = rmin;
166	par[1] = rmax;
167	par[2] = (siThick + pcbThick + legl + modSpace) / 2;
168	name = Form(fgkRingName, id);
169	mc->Gsvolu(name.Data(), "TUBE", airId, par, 3);
170
171	par[0] = rmin;
172	par[1] = rmax;
173	par[2] = siThick / 2;
174	par[3] = -theta;
175	par[4] = theta;
176	name = Form(fgkActiveName, id);
177	mc->Gsvolu(name.Data(), "TUBS", (fDetailed ? airId : siId), par, 5);
178
179	Int_t sid = -1;
180	if (fDetailed) {
181	name2 = name;
182	name = Form(fgkSectorName, id);
183	mc->Gsdvn2(name.Data(), name2.Data(), 2, 2, -theta, airId);
184
185	name2 = name;
186	name = Form(fgkStripName, id);
187	mc->Gsdvt2(name.Data(), name2.Data(), dstrip, 1, stripoff, siId, ns);
188	sid = mc->VolId(name.Data());
189	AliDebug(10, Form("Got volume id %d for volume %s", sid, name.Data()));
190	}
191
192	switch (id) {
193	case 'i':
194	case 'I':
195	fInnerId = sid;
196	// fInnerV = moduleVolume->GetNumber();
197	break;
198	case 'o':
199	case 'O':
200	fOuterId = sid;
201	// fOuterV = moduleVolume->GetNumber();
202	break;
203	}
204
205	// Shape of Printed circuit Board
206	// Top
207	par[0] = c->Y() - off;
208	par[1] = b->Y() - off;
209	par[2] = pcbThick / 2;
210	par[3] = (b->X() - c->X()) / 2;
211	par[4] = off;
212	name = Form(fgkPCBName, id, 'T');
213	mc->Gsvolu(name.Data(), "TRD1", pcbId, par, 4);
214	// Bottom
215	par[0] = a->Y() - off;
216	par[1] = c->Y() - off;
217	par[3] = (c->X() - a->X()) / 2;
218	name = Form(fgkPCBName, id, 'B');
219	mc->Gsvolu(name.Data(), "TRD1", pcbId, par, 4);
220
221	// Short leg volume
222	par[0] = legr - .1;
223	par[1] = legr;
224	par[2] = legl / 2;
225	name = Form(fgkShortLegName, id);
226	mc->Gsvolu(name.Data(), "TUBE", plaId, par, 3);
227
228	// Long leg volume
229	par[2] += modSpace / 2;
230	name = Form(fgkLongLegName, id);
231	mc->Gsvolu(name.Data(), "TUBE", plaId, par, 3);
232
233	// Back container volume
234	par[0] = rmin;
235	par[1] = rmax;
236	par[2] = (siThick + pcbThick + legl) / 2;
237	par[3] = -theta;
238	par[4] = +theta;
239	name = Form(fgkBackVName, id);
240	mc->Gsvolu(name.Data(), "TUBS", airId, par, 5);
241
242	Double_t x = 0;
243	Double_t y = 0;
244	Double_t z = - par[2] + siThick / 2;
245	name2 = name;
246	name = Form(fgkActiveName, id);
247	mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, 0, "ONLY");
248
249	Double_t pbTopL = (b->X() - c->X());
250	Double_t pbBotL = (c->X() - a->X());
251	Int_t pbRot;
252	mc->Matrix(pbRot, 90, 90, 0, 90, 90, 0);
253
254	x = rmin + pbBotL + pbTopL / 2;
255	z += siThick / 2 + pcbThick / 2;
256	name = Form(fgkPCBName, id, 'T');
257	mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, pbRot, "ONLY");
258
259	x = rmin + pbBotL / 2;
260	name = Form(fgkPCBName, id, 'B');
261	mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, pbRot, "ONLY");
262
263	x = a->X() + legoff + legr;
264	y = 0;
265	z += pcbThick / 2 + legl / 2;
266	name = Form(fgkShortLegName, id);
267	mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, 0, "ONLY");
268
269	x = c->X();
270	y = c->Y() - legoff - legr - off;
271	mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, 0, "ONLY");
272
273	y = -y;
274	mc->Gspos(name.Data(), 2, name2.Data(), x, y, z, 0, "ONLY");
275
276
277	// Front container volume
278	par[2] += modSpace / 2;
279	name = Form(fgkFrontVName, id);
280	mc->Gsvolu(name.Data(), "TUBS", airId, par, 5);
281
282	x = 0;
283	y = 0;
284	z = - par[2] + siThick / 2;
285	name2 = name;
286	name = Form(fgkActiveName, id);
287	mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, 0, "ONLY");
288
289	pbTopL = (b->X() - c->X());
290	pbBotL = (c->X() - a->X());
291	x = rmin + pbBotL + pbTopL / 2;
292	z += siThick / 2 + pcbThick / 2;
293	name = Form(fgkPCBName, id, 'T');
294	mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, pbRot, "ONLY");
295
296	x = rmin + pbBotL / 2;
297	name = Form(fgkPCBName, id, 'B');
298	mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, pbRot, "ONLY");
299
300	x = a->X() + legoff + legr;
301	y = 0;
302	z += pcbThick / 2 + legl / 2 + modSpace / 2;
303	name = Form(fgkLongLegName, id);
304	mc->Gspos(name.Data(), 0, name2.Data(), x, y, z, 0, "ONLY");
305
306	x = c->X();
307	y = c->Y() - legoff - legr - off;
308	mc->Gspos(name.Data(), 1, name2.Data(), x, y, z, 0, "ONLY");
309
310	y = -y;
311	mc->Gspos(name.Data(), 2, name2.Data(), x, y, z, 0, "ONLY");
312
313
314
315	Int_t nmod = r->GetNModules();
316	name2 = Form(fgkRingName, id);
317	AliDebug(10, Form("making %d modules in ring %c", nmod, id));
318	for (Int_t i = 0; i < nmod; i++) {
319	Double_t th = (i + .5) * 2 * theta;
320	Bool_t isFront = (i % 2 == 0);
321	name = (isFront ? Form(fgkFrontVName,id) :
322	Form(fgkBackVName,id));
323	Double_t z = (isFront ? 0 : modSpace) / 2;
324	Int_t rot;
325	mc->Matrix(rot, 90, th, 90, fmod(90 + th, 360), 0, 0);
326	mc->Gspos(name.Data(), i, name2.Data(), 0, 0, z, rot, "ONLY");
327	}
328
329	return kTRUE;
330	}
331
332	//____________________________________________________________________
333	Bool_t
334	AliFMDG3Simulator::DetectorGeometry(AliFMDDetector* d, Double_t zmother)
335	{
336	// Common stuff for setting up the FMD1, FMD2, and FMD3 geometries.
337	// This includes putting the Honeycomb support plates and the rings
338	// into the mother volumes.
339	//
340	// Parameeters:
341	// d The detector geometry to use
342	// zmother The midpoint in global coordinates of detector vol.
343	//
344	// Returns:
345	// true on success
346	//
347	if (!d) return kFALSE;
348
349	TString name;
350	TString name2;
351	TVirtualMC* mc = TVirtualMC::GetMC();
352
353	// Loop over the defined rings
354	for (int i = 0; i < 2; i++) {
355	AliFMDRing* r = 0;
356	Double_t lowr = 0;
357	Double_t highr = 0;
358	Double_t rz = 0;
359	switch (i) {
360	case 0:
361	r = d->GetInner();
362	lowr = d->GetInnerHoneyLowR();
363	highr = d->GetInnerHoneyHighR();
364	rz = d->GetInnerZ();
365	break;
366	case 1:
367	r = d->GetOuter();
368	lowr = d->GetOuterHoneyLowR();
369	highr = d->GetOuterHoneyHighR();
370	rz = d->GetOuterZ();
371	break;
372	}
373	if (!r) continue;
374	Char_t c = r->GetId();
375	Int_t id = d->GetId();
376	Int_t airId = (fFMD->GetIdtmed()->At(kAirId));
377	Int_t alId = (fFMD->GetIdtmed()->At(kAlId));
378	Double_t hcThick = d->GetHoneycombThickness();
379	Double_t alThick = d->GetAlThickness();
380	Double_t par[10];
381	Double_t z;
382	// Place ring in mother volume
383	if (zmother > 0) z = rz - zmother + r->GetRingDepth() / 2;
384	else z = zmother - rz + r->GetRingDepth() / 2;
385	name = Form(fgkRingName, c);
386	name2 = d->GetName();
387	mc->Gspos(name.Data(), Int_t(c), name2.Data(), 0, 0, z, 0, "ONLY");
388
389	// Place Top Honeycomb in mother volume
390	z += + r->GetRingDepth() / 2 + hcThick / 2;
391	// Top of Honeycomb
392	par[0] = lowr;
393	par[1] = highr;
394	par[2] = hcThick / 2;
395	par[3] = 0;
396	par[4] = 180;
397	name = Form(fgkTopHCName, id, c);
398	mc->Gsvolu(name.Data(), "TUBS", alId, par, 5);
399	mc->Gspos(name.Data(), 0, name2.Data(), 0, 0, z, 0, "ONLY");
400
401	par[0] += alThick;
402	par[1] -= alThick;
403	par[2] -= alThick / 2;
404	name2 = name;
405	name = Form(fgkTopIHCName, id, c);
406	mc->Gsvolu(name.Data(), "TUBS", airId, par, 5);
407	mc->Gspos(name.Data(), 0, name2.Data(), 0, 0, 0, 0, "ONLY");
408
409	// Bot of Honeycomb
410	par[0] = lowr;
411	par[1] = highr;
412	par[2] = hcThick / 2;
413	par[3] = 180;
414	par[4] = 360;
415	name2 = d->GetName();
416	name = Form(fgkBotHCName, id, c);
417	mc->Gsvolu(name.Data(), "TUBS", alId, par, 5);
418	mc->Gspos(name.Data(), 0, name2.Data(), 0, 0, z, 0, "ONLY");
419
420	par[0] += alThick;
421	par[1] -= alThick;
422	par[2] -= alThick / 2;
423	name2 = name;
424	name = Form(fgkBotIHCName, id, c);
425	mc->Gsvolu(name.Data(), "TUBS", airId, par, 5);
426	mc->Gspos(name.Data(), 0, name2.Data(), 0, 0, 0, 0, "ONLY");
427	}
428	return kTRUE;
429	}
430
431	//____________________________________________________________________
432	Bool_t
433	AliFMDG3Simulator::FMD1Geometry(AliFMD1* fmd1)
434	{
435	// Setup the FMD1 geometry. The FMD1 only has one ring, and no
436	// special support as it is at the momement.
437	//
438	// See also AliFMDG3Simulator::DetectorGeometry
439	//
440	if (!fmd1) return kFALSE;
441	Double_t rmin = fmd1->GetInner()->GetLowR();
442	Double_t rmax = fmd1->GetInnerHoneyHighR();
443	Double_t hcThick = fmd1->GetHoneycombThickness();
444	Double_t w = fmd1->GetInner()->GetRingDepth() + hcThick;
445	Double_t z = fmd1->GetInnerZ() + w / 2;
446	TVirtualMC* mc = TVirtualMC::GetMC();
447	Int_t airId = (fFMD->GetIdtmed()->At(kAirId));
448
449	Double_t par[3];
450	par[0] = rmin;
451	par[1] = rmax;
452	par[2] = w / 2;
453	mc->Gsvolu(fmd1->GetName(), "TUBE", airId, par, 3);
454	mc->Gspos(fmd1->GetName(), fmd1->GetId(), "ALIC", 0, 0, z, 0, "ONLY");
455
456	return DetectorGeometry(fmd1, z);
457	}
458
459	//____________________________________________________________________
460	Bool_t
461	AliFMDG3Simulator::FMD2Geometry(AliFMD2* fmd2)
462	{
463	// Setup the FMD2 geometry. The FMD2 has no
464	// special support as it is at the momement.
465	//
466	// See also AliFMDG3Simulator::DetectorGeometry
467	//
468	if (!fmd2) return kFALSE;
469	Double_t rmin = fmd2->GetInner()->GetLowR();
470	Double_t rmax = fmd2->GetOuterHoneyHighR();
471	Double_t hcThick = fmd2->GetHoneycombThickness();
472	Double_t ow = fmd2->GetInner()->GetRingDepth();
473	Double_t iz = fmd2->GetInnerZ();
474	Double_t oz = fmd2->GetOuterZ();
475	Double_t w = TMath::Abs(oz - iz) + ow + hcThick;
476	Double_t z = oz + w / 2;
477
478	TVirtualMC* mc = TVirtualMC::GetMC();
479	Int_t airId = (fFMD->GetIdtmed()->At(kAirId));
480
481	Double_t par[3];
482	par[0] = rmin;
483	par[1] = rmax;
484	par[2] = w / 2;
485	mc->Gsvolu(fmd2->GetName(), "TUBE", airId, par, 3);
486	mc->Gspos(fmd2->GetName(), fmd2->GetId(), "ALIC", 0, 0, z, 0, "ONLY");
487
488	return DetectorGeometry(fmd2, z);
489	}
490
491	//____________________________________________________________________
492	Bool_t
493	AliFMDG3Simulator::FMD3Geometry(AliFMD3* fmd3)
494	{
495	// Setup the FMD3 geometry. The FMD2 has a rather elaborate support
496	// structure, as the support will also support the vacuum
497	// beam-pipe.
498	//
499	// See also AliFMDG3Simulator::DetectorGeometry
500	//
501	if (!fmd3) return kFALSE;
502	Double_t nlen = fmd3->GetNoseLength();
503	Double_t nz = fmd3->GetNoseZ();
504	Double_t noser1 = fmd3->GetNoseLowR();
505	Double_t noser2 = fmd3->GetNoseHighR();
506	Double_t conel = fmd3->GetConeLength();
507	Double_t backl = fmd3->GetBackLength();
508	Double_t backr1 = fmd3->GetBackLowR();
509	Double_t backr2 = fmd3->GetBackHighR();
510	Double_t zdist = conel - backl - nlen;
511	Double_t tdist = backr2 - noser2;
512	Double_t beaml = TMath::Sqrt(zdist * zdist + tdist * tdist);
513	Double_t theta = -180. * TMath::ATan2(tdist, zdist) / TMath::Pi();
514	Double_t innerZ = fmd3->GetInnerZ();
515	Double_t innerZh = (innerZ - fmd3->GetInner()->GetRingDepth()
516	- fmd3->GetHoneycombThickness());
517	Double_t outerZ = fmd3->GetOuterZ();
518	Double_t outerZh = (outerZ - fmd3->GetOuter()->GetRingDepth()
519	- fmd3->GetHoneycombThickness());
520	Double_t innerr1 = fmd3->GetInner()->GetLowR();
521	// Double_t innerr2 = fmd3->GetInner()->GetHighR();
522	Double_t outerr1 = fmd3->GetOuter()->GetLowR();
523	// Double_t outerr2 = fmd3->GetOuter()->GetHighR();
524	Double_t flanger = fmd3->GetFlangeR();
525	Double_t minZ = TMath::Min(nz - conel, outerZh);
526	Double_t z = fmd3->GetZ();
527	Double_t zi;
528	TVirtualMC* mc = TVirtualMC::GetMC();
529	Int_t airId = (fFMD->GetIdtmed()->At(kAirId));
530	Int_t cId = (fFMD->GetIdtmed()->At(kCarbonId));
531	Double_t par[27];
532
533	// FMD3 volume
534	par[0] = 0;
535	par[1] = 360;
536	par[2] = 8;
537	// First
538	par[3] = z - nz;
539	par[4] = noser1;
540	par[5] = noser2;
541	// Second
542	par[6] = z - (nz - nlen);
543	par[7] = noser1;
544	par[8] = fmd3->ConeR(z - par[6])+.15;
545	// Third
546	par[9] = z - innerZ;
547	par[10] = innerr1;
548	par[11] = fmd3->ConeR(z - par[9])+.15;
549	// Fourth
550	par[12] = z - innerZh;
551	par[13] = innerr1;
552	par[14] = fmd3->ConeR(z - par[12])+.15;
553	// Fifth
554	par[15] = par[12];
555	par[16] = outerr1;
556	par[17] = fmd3->ConeR(z - par[15])+.15;
557	// Sixth
558	par[18] = z - nz + zdist + nlen;
559	par[19] = outerr1;
560	par[20] = fmd3->ConeR(z - par[18])+.15;
561	// Seventh
562	par[21] = z - nz + nlen + zdist;
563	par[22] = outerr1;
564	par[23] = flanger+1.5;
565	// Eight
566	par[24] = z - minZ;
567	par[25] = outerr1;
568	par[26] = flanger+1.5;
569	mc->Gsvolu(fmd3->GetName(), "PCON", airId, par, 27);
570
571	Int_t id;
572	mc->Matrix(id, 270, 180, 90, 90, 180, 0);
573	mc->Gspos(fmd3->GetName(), fmd3->GetId(), "ALIC", 0, 0, z, id, "ONLY");
574
575	// Nose volume
576	par[0] = noser1;
577	par[1] = noser2;
578	par[2] = nlen / 2;
579	zi = z - nz + nlen / 2;
580	mc->Gsvolu(fgkNoseName, "TUBE", cId, par, 3);
581	mc->Gspos(fgkNoseName, 0, fmd3->GetName(), 0, 0, zi, 0, "MANY");
582
583	// Back
584	par[0] = backr1;
585	par[1] = backr2;
586	par[2] = backl / 2;
587	zi = z - nz + conel - backl / 2;
588	mc->Gsvolu(fgkBackName, "TUBE", cId, par, 3);
589	mc->Gspos(fgkBackName, 0, fmd3->GetName(), 0, 0, zi, 0, "ONLY");
590
591	Int_t n;
592	Double_t r;
593	// The flanges
594	par[0] = (flanger - backr2) / 2;
595	par[1] = fmd3->GetBeamWidth() / 2;
596	par[2] = backl / 2;
597	mc->Gsvolu(fgkFlangeName, "BOX", cId, par, 3);
598	n = fmd3->GetNFlange();
599	r = backr2 + (flanger - backr2) / 2;
600	for (Int_t i = 0; i < n; i++) {
601	Double_t phi = 360. / n * i + 180. / n;
602	Double_t x = r * TMath::Cos(TMath::Pi() / 180 * phi);
603	Double_t y = r * TMath::Sin(TMath::Pi() / 180 * phi);
604	Int_t id;
605	mc->Matrix(id, 90, phi, 90, 90 + phi, 0, 0);
606	mc->Gspos(fgkFlangeName, i, fmd3->GetName(), x, y, zi, id, "ONLY");
607	}
608
609	// The Beams
610	par[0] = fmd3->GetBeamThickness() / 2;
611	par[1] = fmd3->GetBeamWidth() / 2;
612	par[2] = beaml / 2;
613	mc->Gsvolu(fgkBeamName, "BOX", cId, par, 3);
614	n = fmd3->GetNBeam();
615	r = noser2 + tdist / 2;
616	zi = z - nz + nlen + zdist / 2;
617	for (Int_t i = 0; i < n; i++) {
618	Double_t phi = 360. / n * i;
619	Double_t x = r * TMath::Cos(TMath::Pi() / 180 * phi);
620	Double_t y = r * TMath::Sin(TMath::Pi() / 180 * phi);
621	Int_t id;
622	(void)theta;
623	mc->Matrix(id, 90-theta, phi, 90, 90 + phi, 360 - theta, phi);
624	mc->Gspos(fgkBeamName, i, fmd3->GetName(), x, y, zi, id, "MANY");
625	}
626
627	return DetectorGeometry(fmd3, z);
628	}
629
630	//____________________________________________________________________
631	void
632	AliFMDG3Simulator::DefineGeometry()
633	{
634	// Setup up the FMD geometry.
635	AliDebug(10, "Setting up volume");
636
637	AliFMDGeometry* fmd = AliFMDGeometry::Instance();
638	if (!RingGeometry(fmd->GetInner())) {
639	AliError("Failed to create inner ring volume");
640	return;
641	}
642	if (!RingGeometry(fmd->GetOuter())) {
643	AliError("Failed to create outer ring volume");
644	return;
645	}
646	FMD1Geometry(fmd->GetFMD1());
647	FMD2Geometry(fmd->GetFMD2());
648	FMD3Geometry(fmd->GetFMD3());
649	}
650
651	//____________________________________________________________________
652	//
653	// EOF
654	//