Geo.h

Go to the documentation of this file.

#ifndef GEO_H
#define GEO_H

// Geo                                                                //
//                                                                    //
// Package: Geo (Geometry). TGeo based geometry package.              //
//                                                                    //
// Concept:  Define data types and static utility methods used by     //
//           Geometry package.                                        //
//                                                                    //
// S. Kasahara  11/2003                                               //
//                                                                    //
#include "Conventions/Detector.h"
#include "Conventions/Munits.h"

namespace Geo {

  // Nominal strip width and thickness
  const Float_t kStripWidth     = 4.1 * Munits::cm;
  const Float_t kStripThick     = 1.0 * Munits::cm;

  // Nominal thickness of coextruded TiO2/Polystyrene coating
  const Float_t kCoexThick      = 0.025 * Munits::cm;

  // Nominal module Al skin thickness
  const Float_t kModuleSkinThick = 0.05 * Munits::cm; // tdr
  // Nominal module coil hole radius defined by coil bypass region below.
  const Float_t kFarModuleHoleRad  = 19.7* Munits::cm; 
  // The near detector coil hole radius defined here applies to the full
  // coverage planes
  const Float_t kNearModuleHoleRad = 27.9* Munits::cm;
  
  // Nominal steel width
  const Float_t kFarSteelWidth  = 8.0 * Munits::m;
  const Float_t kCalDetSteelWidth  = 1.0 * Munits::m;
  
  // Near coil hole center offset (== u,v origin offset)
  const Float_t kNearXOffset = -55.78 * Munits::cm;

  // Coil dimensions from R. Hatcher's $GMINOSPATH/inc/coil_info.inc
  // and references therein.  For far detector, the following dimensions
  // are used to define the radius of a tube. For the near detector,
  // the dimensions are used to define the half-width of a box.
  const Float_t kCoilRad   = 12.0 * Munits::cm; // magnetized conducting coil
  const Float_t kThroatRad = 13.0 * Munits::cm; // magnetized air
  const Float_t kNeckRad   = 14.0 * Munits::cm; // magnetized iron
  const Float_t kFeHoleRad = 15.0 * Munits::cm; // magnetized air
  // kFlange applies to region between steel planes (scint pln + air gaps)
  const Float_t kFlangeRad = 17.0 * Munits::cm; // magnetized iron
  // kDetail defines region within steel plane to which detailed
  // magnetic field map applies
  const Float_t kDetailRad = 29.8 * Munits::cm; // magnetized steel (FEPL)
  // Bypass region defines region within scint planes and air gaps, in air
  // filled coil bypass region, to which detailed field map will be applied. 
  // For near full and far scint planes, the bypass radius is
  // used to defined the radius of a tube.  For near partial, the bypass 
  // radius is used to define the halfwidth of a box.
  const Float_t kNearFullBypassRad    = 27.9 * Munits::cm; // magnetized air
  const Float_t kNearPartialBypassRad = 18.0 * Munits::cm; // magnetized air
  const Float_t kFarBypassRad         = 19.7 * Munits::cm; // magnetized air
  // Cooling tubes inserted into near detector coil
  const Float_t kNearCoolRad =  0.8255 * Munits::cm; // magnetized water

  enum EAppType {
    // Geometry application type
    kRecons, // for use in minos reconstruction framework
    kVMC,    // for use in virtual monte carlo application
    kUnknownAppType
  };

  enum ESwimMethod {
    // Bfield swim method.  Assigned to medium and used to determine 
    // transport model used to swim particles through that medium in VMC.
    kNoFieldSwim,  // swim as though no b-field
    // Runge-Kutta method recommended for fields with a strong gradient.
    kRungeKutta,
    // Step-wise helix method recommended for fields with a small gradient.
    // Tracking is performed along helix for each step, assuming a
    // constant B-field with the value of the step mid-point.
    // Better performance than kRungeKutta.
    kStepHelix,
    kUnknownSwimMethod 
  };
    
  enum EDetComponent {
    // Detector components
    kMars,         // rock
    kLinr,         // cavern liner
    kHall,         // cavern hall
    kStpScint,     // strip scintillator
    kStpTiO2,      // strip TiO2 coex coating
    kMdlAlSkin,    // scint module Al skin
    kMdlAir,       // scint module Air fill
    kPlnScint,     // scint plane Air fill
    kPlnSteel,     // steel plane
    kPlnAirGap,    // scint/steel pln air gap 
    kCRGapWater,   // coil region air gap water
    kCRGapCoil,    // coil region air gap coil
    kCRGapThroat,  // coil region air gap throat
    kCRGapFlange,  // coil region air gap flange
    kCRGapBypass,  // coil region air gap bypass
    kCRStlWater,   // coil region steel pln water
    kCRStlCoil,    // coil region steel pln coil
    kCRStlThroat,  // coil region steel pln throat
    kCRStlNeck,    // coil region steel pln neck
    kCRStlHole,    // coil region steel pln hole
    kCRStlDetail,  // coil region steel pln detail
    kCRSctWater,   // coil region scint pln water
    kCRSctCoil,    // coil region scint pln coil
    kCRSctThroat,  // coil region scint pln throat 
    kCRSctFlange,  // coil region scint pln flange
    kCRSctBypass,  // coil region scint pln bypass
    kRCCoil,       // return coil 
    kRCAir,        // return coil air fill
    kRCShaft,      // return coil shaft 
    kVSStpScint,   // strip scintillator
    kVSStpTiO2,    // strip TiO2 coex coating
    kVSMdlAlSkin,  // scint module Al skin
    kVSMdlAir,     // scint module Air fill
    kVSPlnScint,   // scint plane Air fill
    kSoLo,         // soudan low background counting facilities (lead stacks)
    kUnknownDetComponent  // unknown
  };
      
  enum EFldStrength {
    // Field strength assigned to detector components
    kNoField,      // e.g. hall,rock
    kLowField,     // e.g. scint plane,plane air gaps
    kHighField,    // e.g. steel plane, coil
    kUnknownFldStrength // unknown 
  };

  // Return scale factor appropriate for application type (vmc or reco)
  Float_t GetScale(EAppType apptype);

  // Return character string associated with enumerated type
  const char* AsString(EAppType apptype);
  const char* AsString(ESwimMethod swimmethod);
  const char* AsString(EDetComponent detcomponent);
  const char* AsString(EFldStrength fldstrength);

  // Return enumerated type associated with the character string
  EAppType GetAppType(const char* apptypename);
  ESwimMethod GetSwimMethod(const char* swimmethodname);
  EDetComponent GetDetComponent(const char* detcomponentname);
  EFldStrength GetFldStrength(const char* fldstrengthname);
  
}
#endif  // GEO_H

---