Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

GeoMediumMap Class Reference

#include <GeoMediumMap.h>

List of all members.

Public Types

typedef std::map< Geo::EDetComponent,
GeoMedium * > 		MediumMap
typedef MediumMap::const_iterator MediumMapConstItr
typedef MediumMap::iterator MediumMapItr
typedef std::map< Geo::EDetComponent,
Geo::EFldStrength > 		FldStrengthMap
typedef FldStrengthMap::const_iterator FldStrengthMapConstItr
typedef FldStrengthMap::iterator FldStrengthMapItr
typedef std::map< Geo::EFldStrength,
Geo::ESwimMethod > 		SwimMethodMap
typedef SwimMethodMap::const_iterator SwimMethodMapConstItr
typedef SwimMethodMap::iterator SwimMethodMapItr

Public Member Functions

 GeoMediumMap ()
virtual ~GeoMediumMap ()
virtual GeoMedium * GetMedium (Geo::EDetComponent detcomp) const
virtual Geo::EFldStrength GetFldStrength (Geo::EDetComponent detcomp) const
virtual Geo::ESwimMethod GetSwimMethod (Geo::EFldStrength fldstrength) const
virtual void Print (Option_t *option="") const
virtual void UpdateGlobalManager () const

Protected Member Functions

 GeoMediumMap (GeoGeometry *geo, const VldContext &vldc)

Private Member Functions

void BuildMediums ()
bool BuildMediumMap ()
void BuildSwimMethodMap ()
void BuildFarMediumMap ()
void BuildNearMediumMap ()
void BuildCalMediumMap ()
void BuildDefMediumMap ()
void SetMedium (Geo::EDetComponent, std::string medname, Geo::EFldStrength)
int CreateMediumsforMaterial (std::string medname, int medId, int matId, int isVol, float fieldm)
void ConfigureMedium (GeoMedium *med)

Private Attributes

GeoGeometry * fGeoGeometry
VldContext fVldContext
 reference link to geometry creator
MediumMap fMediumMap
FldStrengthMap fFldStrengthMap
SwimMethodMap fSwimMethodMap

Friends

class GeoGeometry

Member Typedef Documentation

typedef std::map<Geo::EDetComponent,Geo::EFldStrength> GeoMediumMap::FldStrengthMap
 

Definition at line 33 of file GeoMediumMap.h.

typedef FldStrengthMap::const_iterator GeoMediumMap::FldStrengthMapConstItr
 

Definition at line 34 of file GeoMediumMap.h.

Referenced by GetFldStrength().

typedef FldStrengthMap::iterator GeoMediumMap::FldStrengthMapItr
 

Definition at line 35 of file GeoMediumMap.h.

typedef std::map<Geo::EDetComponent,GeoMedium*> GeoMediumMap::MediumMap
 

Definition at line 30 of file GeoMediumMap.h.

typedef MediumMap::const_iterator GeoMediumMap::MediumMapConstItr
 

Definition at line 31 of file GeoMediumMap.h.

Referenced by GetMedium(), and Print().

typedef MediumMap::iterator GeoMediumMap::MediumMapItr
 

Definition at line 32 of file GeoMediumMap.h.

typedef std::map<Geo::EFldStrength,Geo::ESwimMethod> GeoMediumMap::SwimMethodMap
 

Definition at line 36 of file GeoMediumMap.h.

typedef SwimMethodMap::const_iterator GeoMediumMap::SwimMethodMapConstItr
 

Definition at line 37 of file GeoMediumMap.h.

typedef SwimMethodMap::iterator GeoMediumMap::SwimMethodMapItr
 

Definition at line 38 of file GeoMediumMap.h.

Constructor & Destructor Documentation

GeoMediumMap::GeoMediumMap (   )  [inline]
 

Definition at line 41 of file GeoMediumMap.h.

References fGeoGeometry.

00041 :fGeoGeometry(0) {} // def, used by i/o

virtual GeoMediumMap::~GeoMediumMap (   )  [inline, virtual]
 

Definition at line 42 of file GeoMediumMap.h.

00042 {}

GeoMediumMap::GeoMediumMap (  GeoGeometry *  geo,
const VldContext &  vldc
)  [protected]
 

Definition at line 32 of file GeoMediumMap.cxx.

References MSG.

00032                                                                   : 
00033                            fGeoGeometry(geo),fVldContext(vldc) {
00034   // Normal constructor. Protected. Invoked by GeoGeometry creator.
00035 
00036   MSG("Geo",Msg::kDebug) << "GeoMediumMap normal ctor @ " << this 
00037                          << " w/vldc " << vldc << " fGeoGeometry "
00038                          << fGeoGeometry << endl;
00039 
00040   UpdateGlobalManager();
00041   
00042   BuildMediums();
00043   BuildMediumMap();
00044 
00045 }

Member Function Documentation

void GeoMediumMap::BuildCalMediumMap (   )  [private]
 

Definition at line 725 of file GeoMediumMap.cxx.

References SetMedium().

Referenced by BuildMediumMap().

00725                                      {
00726   // Private method to build medium map for the calibration detector.
00727 
00728   // No magnetic field is present in the calibration detector
00729   SetMedium(Geo::kMars,       "ROCK",               Geo::kNoField); // rock 
00730   SetMedium(Geo::kLinr,       "CONCRETE",           Geo::kNoField); // liner
00731   SetMedium(Geo::kHall,       "AIR",                Geo::kNoField); // hall
00732   SetMedium(Geo::kVSStpScint, "PSTYRENE SCINT",  Geo::kNoField); // veto shield
00733   SetMedium(Geo::kVSStpTiO2,  "COEX TIO2 PSTYRENE", Geo::kNoField);
00734   SetMedium(Geo::kVSMdlAlSkin,"ALUM",               Geo::kNoField);
00735   SetMedium(Geo::kVSMdlAir,   "AIR",                Geo::kNoField);
00736   SetMedium(Geo::kVSPlnScint, "AIR",                Geo::kNoField); 
00737   SetMedium(Geo::kStpScint,   "PSTYRENE SCINT",     Geo::kNoField);
00738   SetMedium(Geo::kStpTiO2,    "COEX TIO2 PSTYRENE", Geo::kNoField);
00739   SetMedium(Geo::kMdlAlSkin,  "ALUM",               Geo::kNoField);
00740   SetMedium(Geo::kMdlAir,     "AIR",                Geo::kNoField);
00741   SetMedium(Geo::kPlnScint,   "AIR",                Geo::kNoField);
00742   SetMedium(Geo::kPlnAirGap,  "AIR",                Geo::kNoField);
00743   SetMedium(Geo::kPlnSteel,   "FEPL",             Geo::kNoField); // steel pln 
00744   
00745 }

void GeoMediumMap::BuildDefMediumMap (   )  [private]
 

Definition at line 748 of file GeoMediumMap.cxx.

References SetMedium().

Referenced by BuildMediumMap().

00748                                      {
00749   // Private method to build medium map for a default detector.
00750 
00751   // No magnetic field is present in the default detector which is
00752   // an empty hall
00753   SetMedium(Geo::kMars,       "ROCK",          Geo::kNoField); // rock 
00754   SetMedium(Geo::kLinr,       "CONCRETE",      Geo::kNoField); // liner
00755   SetMedium(Geo::kHall,       "AIR",           Geo::kNoField); // hall
00756   
00757 }

void GeoMediumMap::BuildFarMediumMap (   )  [private]
 

Definition at line 637 of file GeoMediumMap.cxx.

References SetMedium().

Referenced by BuildMediumMap().

00637                                      {
00638   // Private method to build medium map for the far detector.
00639 
00640   // The following regions are never likely to have a field implemented
00641   SetMedium(Geo::kMars,       "GREENSTONE",      Geo::kNoField); // rock 
00642   SetMedium(Geo::kLinr,       "GREENSTONE",      Geo::kNoField); // liner
00643   SetMedium(Geo::kHall,       "AIR",             Geo::kNoField); // hall
00644   SetMedium(Geo::kRCCoil,     "FARCOIL",         Geo::kNoField); // return coil
00645   SetMedium(Geo::kRCAir,      "AIR",             Geo::kNoField); 
00646   SetMedium(Geo::kVSStpScint, "PSTYRENE SCINT",  Geo::kNoField); // veto shield
00647   SetMedium(Geo::kVSStpTiO2,  "COEX TIO2 PSTYRENE", Geo::kNoField);
00648   SetMedium(Geo::kVSMdlAlSkin,"ALUM",               Geo::kNoField);
00649   SetMedium(Geo::kVSMdlAir,   "AIR",                Geo::kNoField);
00650   SetMedium(Geo::kVSPlnScint, "AIR",                Geo::kNoField); 
00651   SetMedium(Geo::kSoLo,       "LEAD",               Geo::kNoField);
00652   
00653   // The following regions in the main detector but outside the steel
00654   // and coil region will have no field or low field implemented
00655   SetMedium(Geo::kStpScint,   "PSTYRENE SCINT",    Geo::kLowField);
00656   SetMedium(Geo::kStpTiO2,    "COEX TIO2 PSTYRENE",Geo::kLowField);
00657   SetMedium(Geo::kMdlAlSkin,  "ALUM",              Geo::kLowField);
00658   SetMedium(Geo::kMdlAir,     "AIR",               Geo::kLowField);
00659   SetMedium(Geo::kPlnScint,   "AIR",               Geo::kLowField);
00660   SetMedium(Geo::kPlnAirGap,  "AIR",               Geo::kLowField);
00661 
00662   // The following regions in the steel and in the coil region have a
00663   // strong field implemented
00664   SetMedium(Geo::kPlnSteel,   "FEPL",         Geo::kHighField); // steel pln 
00665   SetMedium(Geo::kCRGapCoil,  "FARCOIL",      Geo::kHighField); // air gap CR
00666   SetMedium(Geo::kCRGapThroat,"AIR",          Geo::kHighField); 
00667   SetMedium(Geo::kCRGapFlange,"IRON",         Geo::kHighField);
00668   SetMedium(Geo::kCRGapBypass,"AIR",          Geo::kHighField);
00669   SetMedium(Geo::kCRStlCoil,  "FARCOIL",      Geo::kHighField); // steel pln CR
00670   SetMedium(Geo::kCRStlThroat,"AIR",          Geo::kHighField);
00671   SetMedium(Geo::kCRStlNeck,  "IRON",         Geo::kHighField);
00672   SetMedium(Geo::kCRStlHole,  "AIR",          Geo::kHighField);
00673   SetMedium(Geo::kCRStlDetail,"FEPL",         Geo::kHighField);
00674   SetMedium(Geo::kCRSctCoil,  "FARCOIL",      Geo::kHighField); // scint pln CR
00675   SetMedium(Geo::kCRSctThroat,"AIR",          Geo::kHighField);
00676   SetMedium(Geo::kCRSctFlange,"IRON",         Geo::kHighField);
00677   SetMedium(Geo::kCRSctBypass,"AIR",          Geo::kHighField);
00678   
00679 }

bool GeoMediumMap::BuildMediumMap (   )  [private]
 

Definition at line 599 of file GeoMediumMap.cxx.

References BuildCalMediumMap(), BuildDefMediumMap(), BuildFarMediumMap(), BuildNearMediumMap(), BuildSwimMethodMap(), fVldContext, and VldContext::GetDetector().

00599                                   {
00600   // Private method to build medium map for given validity context
00601 
00602   bool isOkay = true;
00603   Detector::Detector_t dettype = fVldContext.GetDetector();
00604 
00605   // Set up swim method 
00606   BuildSwimMethodMap();
00607   
00608   switch( dettype ) {
00609 
00610   case Detector::kFar:
00611 
00612     BuildFarMediumMap();
00613     break;
00614    
00615   case Detector::kNear:
00616 
00617     BuildNearMediumMap();
00618     break;
00619 
00620   case Detector::kCalDet:
00621 
00622     BuildCalMediumMap();
00623     break;
00624    
00625   default:
00626 
00627     BuildDefMediumMap();
00628     break;
00629 
00630   } // end of switch
00631 
00632   return isOkay;
00633   
00634 }

void GeoMediumMap::BuildMediums (   )  [private]
 

Definition at line 89 of file GeoMediumMap.cxx.

References ConfigureMedium(), CreateMediumsforMaterial(), UtilMCFlag::ECut, UtilMCFlag::EProcess, fVldContext, VldContext::GetDetector(), MSG, and UpdateGlobalManager().

00089                                 {
00090    // Private. Build this geometry's materials.
00091 
00092    UpdateGlobalManager();
00093 
00094    MSG("Geo",Msg::kDebug) << "GeoMediumMap::BuildMediums " << endl;
00095    assert(gGeoManager);
00096 
00097 //-----------List of Materials, Mixtures and Tracking Media--------------
00098    // Arguments for Medium definitions: 
00099    //            medName,medId,matId,
00100    //            isVol  (Sensitive volume flag, set 0 if not sensitive)
00101    //            iField (User defined magnetic field, set
00102    //                    0, if no magnetic field
00103    //                    1, tracking performed with GRKUTA 
00104    //                       (use for strongly inhomogeneous field)
00105    //                    2, tracking performed with GHELIX
00106    //                       (use for inhomogeneous field)
00107    //                    3, tracking performed with GHELX3
00108    //                       (use for uniform magnetic field along z axis)
00109    //            fieldM (Max field value (in kGauss)),
00110    //            tMaxFd (Max angle due to field deflection in one step (deg)),
00111    //            steMax (Max step allowed (cm)),
00112    //            deeMax (Max fractional energy loss in a step),
00113    //            epsil  (Boundary crossing precision (cm)),
00114    //            stMin  (Minimum step due to energy loss, multiple scattering,
00115    //                    Cerenkov or B-fields (cm))
00116 
00117 
00118    // Default max field values for field activated mediums 
00119    Float_t fieldM_iron = 20.; // kGauss, in iron collar or steel plane
00120    Float_t fieldM      = 6.;  // kGauss, outside of iron collar or steel plane 
00121 
00122    // Sensitive volume flags
00123    Int_t isSens    = 1;
00124    Int_t isNotSens = 0;
00125    
00126    // Default boundary crossing precision
00127    Int_t medId = 1; // id assigned to first medium, incr with each new medium
00128    Int_t matId = 1; // id assigned to first material, incr with each new mat
00129    
00130    
00131    // **********  ALUMINIUM **************
00132    //MinosMaterial::StdMaterial_t matAl = MinosMaterial::eAluminium;
00133    TGeoMaterial *mat1 = new TGeoMaterial("ALUMINIUM",26.98, 13, 2.7); 
00134    mat1->SetUniqueID(matId);
00135    medId = CreateMediumsforMaterial("ALUM",medId,matId,isNotSens,fieldM);
00136 
00137    medId++;
00138    matId++;
00139    
00140 
00141    // ************** IRON ***************
00142    //MinosMaterial::StdMaterial_t matFe = MinosMaterial::eIron;
00143    TGeoMaterial *mat2 = new TGeoMaterial("IRON",55.85, 26, 7.87);
00144    mat2->SetUniqueID(matId);
00145    medId = CreateMediumsforMaterial("IRON",medId, matId,isNotSens,fieldM_iron);
00146 
00147    medId++;
00148    matId++;
00149   
00150 
00151    // ************** AIR ****************
00152    TGeoMixture *mat3 = new TGeoMixture("AIR",2,0.1205000E-02);
00153    mat3->SetUniqueID(matId);
00154    mat3->DefineElement(0,14.01,7,0.7);
00155    mat3->DefineElement(1,16.00,8,0.3);
00156    medId = CreateMediumsforMaterial("AIR",medId, matId,isNotSens,fieldM);
00157 
00158    medId++;
00159    matId++;
00160 
00161 
00162    // ************** CONCRETE ****************
00163    //MinosMaterial::StdMaterial_t matConcrete = MinosMaterial::eConcrete;
00164    TGeoMixture *mat4 = new TGeoMixture("CONCRETE",6, 2.5); 
00165    mat4->SetUniqueID(matId);
00166    mat4->DefineElement(0,16,8,0.53);
00167    mat4->DefineElement(1,28.09,14,0.33);
00168    mat4->DefineElement(2,40.078,20,0.6300000E-01);
00169    mat4->DefineElement(3,22.99,11,0.1500000E-01);
00170    mat4->DefineElement(4,55.85,26,0.2000000E-01);
00171    mat4->DefineElement(5,26.98,13,0.4200000E-01);
00172    medId = CreateMediumsforMaterial("CONCRETE",medId, matId,isNotSens,fieldM);
00173 
00174    medId++;
00175    matId++;
00176    
00177 
00178    // *************** ROCK *****************
00179    // ROCK once used for far detector rock. Density should be closer to 2.85.
00180    // Replaced with GREENSTONE on 2007/09/13.
00181    TGeoMixture *mat5 = new TGeoMixture("ROCK",6, 2.5); 
00182    mat5->SetUniqueID(matId);
00183    mat5->DefineElement(0,16,8,0.53);  // oxygen, 53%
00184    mat5->DefineElement(1,28.09,14,0.33); // silicon 33%
00185    mat5->DefineElement(2,40.078,20,0.6300000E-01); // calcium, 6.3%
00186    mat5->DefineElement(3,22.99,11,0.1500000E-01);  // sodium, 1.5%
00187    mat5->DefineElement(4,55.85,26,0.2000000E-01);  // iron, 2%
00188    mat5->DefineElement(5,26.98,13,0.4200000E-01);  // aluminum, 4.2%
00189    medId = CreateMediumsforMaterial("ROCK",medId, matId,isNotSens,fieldM);
00190 
00191    medId++;
00192    matId++;
00193    
00194 
00195    // *************** PSTYRENE SCINT  *****************
00196    //   MinosMaterial::StdMaterial_t matScint=MinosMaterial::ePolystyreneMinos;
00197    // Pure pstyrene is C6H5CH.
00198    TGeoMixture *mat6 = new TGeoMixture("PSTYRENE SCINT",2, 1.0457); 
00199    mat6->SetUniqueID(matId);
00200    mat6->DefineElement(0,1.00794,1,0.7742105E-01);
00201    mat6->DefineElement(1,12.011,6,0.9225789);
00202    // Sensitve medium pstyrene scint, used for scint strips
00203    medId = CreateMediumsforMaterial("PSTYRENE SCINT",medId,matId,isSens,
00204                                      fieldM);
00205 
00206    medId++;
00207    matId++;
00208 
00209 
00210 
00211    // *************** COEX TIO2 PSTYRENE  *****************
00212    //MinosMaterial::StdMaterial_t matTiO2=MinosMaterial::ePolystyreneMinos;
00213    // Pure pstyrene is C6H5CH. Coex Pstyrene is  10% TiO2 by weight
00214    TGeoMixture *mat7 = new TGeoMixture("COEX TIO2 PSTYRENE",4, 1.0457); 
00215    mat7->SetUniqueID(matId);
00216    mat7->DefineElement(0,1.00794,1,0.6967895E-01);
00217    mat7->DefineElement(1,12.011,6,0.8303211);
00218    mat7->DefineElement(2,47.93,22,0.5996587E-01);
00219    mat7->DefineElement(3,15.9994,8,0.4003413E-01);
00220    // Coex TiO2 used for white coating on surface of scint strips
00221    medId = CreateMediumsforMaterial("COEX TIO2 PSTYRENE",medId,matId,
00222                                      isNotSens,fieldM);
00223 
00224    medId++;
00225    matId++;
00226    
00227 
00228    // ******************** FARCOIL **********************
00229    TGeoMixture *mat8 = new TGeoMixture("FARCOIL",5,   2.34881    );
00230    mat8->SetUniqueID(matId);
00231    mat8->DefineElement(0,1.00794,1,0.1281415E-01);
00232    mat8->DefineElement(1,12.0107,6,0.6021570E-01);
00233    mat8->DefineElement(2,14.00674,7,0.1974151E-03);
00234    mat8->DefineElement(3,15.9994,8,0.2134690E-01);
00235    mat8->DefineElement(4,63.546,29,0.9054258);
00236    medId = CreateMediumsforMaterial("FARCOIL",medId, matId,isNotSens,fieldM);
00237 
00238    medId++;
00239    matId++;
00240    
00241 
00242    // ******************* DOLOMITE ********************
00243    // DOLOMITE once used for near det rock. Density should be closer to 2.5?
00244    // Replaced with NEARBEDROCK on 2007/09/13.
00245    TGeoMixture *mat9 = new TGeoMixture("DOLOMITE",5,   2.850000    );
00246    mat9->SetUniqueID(matId);
00247    mat9->DefineElement(0,40.078,20,0.2161123); // calcium 21.6%
00248    mat9->DefineElement(1,24.305,12,0.1310597); // magnesium 13.1%
00249    mat9->DefineElement(2,12.011,6,0.1295336);  // carbon 13.0%
00250    mat9->DefineElement(3,15.9994,8,0.5226618); // oxygen 52.3%
00251    mat9->DefineElement(4,1.0079,1,0.6326329E-03);  // hydrogen 0.06%
00252    medId = CreateMediumsforMaterial("DOLOMITE",medId, matId,isNotSens,fieldM);
00253 
00254    medId++;
00255    matId++;
00256 
00257    
00258    // ******************** FEPL **********************
00259    // FEPL MINOS Steel plane mixture  
00260    //MinosMaterial::StdMaterial_t matSteel=MinosMaterial::eIronMinos;
00261    Double_t densFEPL = 7.847;
00262    if ( fVldContext.GetDetector() == Detector::kCalDet ) densFEPL = 7.85;
00263    TGeoMixture *mat10 = new TGeoMixture("FEPL",17, densFEPL);
00264    mat10->SetUniqueID(matId);
00265    mat10->DefineElement(0,54,26,0.5556792E-01);
00266    mat10->DefineElement(1,56,26,0.9046049);
00267    mat10->DefineElement(2,57,26,0.2126433E-01);
00268    mat10->DefineElement(3,58,26,0.2879539E-02);
00269    mat10->DefineElement(4,54.94,25,0.1016047E-01);
00270    mat10->DefineElement(5,28.09,14,0.2917362E-02);
00271    mat10->DefineElement(6,12.01,6,0.1810777E-02);
00272    mat10->DefineElement(7,58.7,28,0.2112573E-03);
00273    mat10->DefineElement(8,52,24,0.1810777E-03);
00274    mat10->DefineElement(9,30.97,15,0.1508981E-03);
00275    mat10->DefineElement(10,32.06,16,0.8047896E-04);
00276    mat10->DefineElement(11,63.55,29,0.7041910E-04);
00277    mat10->DefineElement(12,26.98,13,0.3017961E-04);
00278    mat10->DefineElement(13,14.01,7,0.3017961E-04);
00279    mat10->DefineElement(14,118.69,50,0.2011974E-04);
00280    mat10->DefineElement(15,47.9,22,0.1005987E-04);
00281    mat10->DefineElement(16,50.94,23,0.1005987E-04);
00282    medId = CreateMediumsforMaterial("FEPL",medId, matId,isNotSens,fieldM_iron);
00283    
00284    medId++;
00285    matId++;
00286    
00287 
00288    // ****************** WATER *******************
00289    MinosMaterial::StdMaterial_t matWater=MinosMaterial::eWater;
00290    TGeoMixture* mat11 = new TGeoMixture("WATER",2,
00291                                    MinosMaterial::Density(matWater) ); // 1.0
00292    mat11 -> SetUniqueID(matId);
00293    mat11 -> DefineElement(0,1.00794,1,0.1118984);
00294    mat11 -> DefineElement(1,15.9994,8,0.8881017);
00295    medId = CreateMediumsforMaterial("WATER",medId,matId,isNotSens,fieldM);
00296 
00297    medId++;
00298    matId++;
00299    
00300 
00301    // *************** GREENSTONE *****************
00302    // GREENSTONE to be used for far detector rock. 
00303    // Composition from K. Ruddick's compilation of data from regional rock 
00304    // samples (c. 1970).  Private communication of 6/21/2007.
00305    // New density of 2.760 introduced on 9/30/2009.  This more precise
00306    // value is from M. Strait's MINOS DocDB #5022.
00307    // Replaces density of 2.8 from K. Ruddick's PDK Note 435, 1990.
00308    TGeoMixture *mat12 = new TGeoMixture("GREENSTONE",13, 2.760); 
00309    mat12->SetUniqueID(matId);
00310    mat12->DefineElement( 0,15.999, 8,0.4586);  // oxygen,    45.86%
00311    mat12->DefineElement( 1,28.086,14,0.2370);  // silicon,   23.70%
00312    mat12->DefineElement( 2,55.845,26,0.0856);  // iron,       8.56%
00313    mat12->DefineElement( 3,26.982,13,0.0797);  // aluminum,   7.97%
00314    mat12->DefineElement( 4,40.078,20,0.0641);  // calcium,    6.41%
00315    mat12->DefineElement( 5,24.305,12,0.0395);  // magnesium,  3.95%
00316    mat12->DefineElement( 6,22.990,11,0.0190);  // sodium,     1.90%
00317    mat12->DefineElement( 7,47.867,22,0.0064);  // titanium,   0.64%
00318    mat12->DefineElement( 8,39.098,19,0.0034);  // potassium,  0.34%
00319    mat12->DefineElement( 9, 1.008, 1,0.0026);  // hydrogen,   0.26%
00320    mat12->DefineElement(10,12.011, 6,0.0020);  // carbon,     0.20%
00321    mat12->DefineElement(11,54.938,25,0.0015);  // manganese,  0.15%
00322    mat12->DefineElement(12,30.974,15,0.0006);  // phosphorus, 0.06%
00323    medId = CreateMediumsforMaterial("GREENSTONE",medId,matId,isNotSens,fieldM);
00324 
00325    medId++;
00326    matId++;
00327    
00328 
00329    // *************** NEARBEDROCK *****************
00330    // NEARBEDROCK to be used for near detector bedrock. 
00331    // Composition (CaMg(CO_3)_2 with 8.0% moisture content by weight) 
00332    // and density from S. Kasahara's NuMI note 2777 and references 
00333    // therein.
00334 
00335    TGeoMixture *mat13 = new TGeoMixture("NEARBEDROCK",5, 2.43); 
00336    mat13->SetUniqueID(matId);
00337    mat13->DefineElement( 0,15.999, 8,0.550);  // oxygen,    55.0%
00338    mat13->DefineElement( 1,40.078,20,0.200);  // calcium,   20.0%
00339    mat13->DefineElement( 2,24.305,12,0.121);  // magnesium, 12.1%
00340    mat13->DefineElement( 3,12.011, 6,0.120);  // carbon,    12.0%
00341    mat13->DefineElement( 4, 1.008, 1,0.009);  // hydrogen,   0.9%
00342    medId = CreateMediumsforMaterial("NEARBEDROCK",medId,matId,isNotSens,
00343                                      fieldM);
00344 
00345    medId++;
00346    matId++;
00347    
00348 
00349    // ************** LEAD ***************
00350    // Lead is used as medium of SOLO (SOudan LOw Background Counting) 
00351    // and "Reeve's Castle" detectors located upstream of the main detector 
00352    // in far detector cavern. Atomic mass and density of lead are taken 
00353    // from 2007 PDG.
00354    TGeoMaterial *mat14 = new TGeoMaterial("LEAD",207.2,82,11.35);
00355    mat14->SetUniqueID(matId);
00356    medId = CreateMediumsforMaterial("LEAD",medId, matId,isNotSens,fieldM);
00357 
00358    medId++;
00359    matId++;
00360 
00361    // At the end of the build of all media, build a duplicate set
00362    // for use with the GeoSwimmer.  These media will have their
00363    // physics process flags and cut thresholds adjusted to suit
00364    // continuous energy loss when using GeoSwimmer with a concrete
00365    // VMC.
00366    Int_t nmed = medId - 1;
00367    TList* medList = gGeoManager -> GetListOfMedia();
00368    for ( int imed = 0; imed < nmed; imed++ ) {
00369      GeoMedium* medium = dynamic_cast<GeoMedium*>(medList->At(imed));
00370      std::string medName = medium->GetName();
00371      Int_t npos = medName.find("_B");
00372      std::string medBaseName = medName.substr(0,npos);
00373      std::string medSwimName 
00374        = medBaseName+"_SWIM"+medName.substr(npos,medName.length()-npos);
00375 
00376      // TGeoMedium copy ctor is protected or we wouldn't have to do this
00377      TGeoMaterial* material = medium -> GetMaterial();
00378      Double_t param[20];
00379      for ( int ipar = 0; ipar < 20; ipar++ ) {
00380        param[ipar] = medium -> GetParam(ipar);
00381      }
00382      param[6] = 0.01; // epsil (Boundary crossing precision (cm)) always 0.01. 
00383      GeoMedium* swimMed= new GeoMedium(medSwimName.c_str(),medId++,material,
00384                                        param);
00385      // Override default physic process and cut flag values
00386      for ( EProcess ip = EProcess(0); ip < kNProcess; ip = EProcess(ip+1) ) {
00387        if ( ip == kLOSS ) swimMed -> SetProcess(kLOSS,4);
00388        else swimMed -> SetProcess(ip,0);
00389      }
00390      for ( ECut ic = ECut(0); ic < kNCut; ic = ECut(ic+1) ) {
00391        if ( ic == kTOFMAX ) continue;
00392        if ( ic == kCUTMUO ) swimMed -> SetCut(kCUTMUO,0.0001);
00393        else swimMed -> SetCut(ic,1000.);
00394      }
00395      ConfigureMedium(swimMed); // configure swimmed if specified by user
00396    }
00397    
00398    
00399    return;
00400 
00401 }

void GeoMediumMap::BuildNearMediumMap (   )  [private]
 

Definition at line 682 of file GeoMediumMap.cxx.

References SetMedium().

Referenced by BuildMediumMap().

00682                                       {
00683   // Private method to build medium map for the near detector.
00684 
00685   // The following regions are never likely to have a field implemented
00686   SetMedium(Geo::kMars,       "NEARBEDROCK",  Geo::kNoField); // rock 
00687   SetMedium(Geo::kLinr,       "NEARBEDROCK",  Geo::kNoField); // liner
00688   SetMedium(Geo::kHall,       "AIR",          Geo::kNoField); // hall
00689   SetMedium(Geo::kRCCoil,     "ALUM",         Geo::kNoField); // return coil
00690   SetMedium(Geo::kRCAir,      "AIR",          Geo::kNoField); 
00691   SetMedium(Geo::kRCShaft,    "IRON",         Geo::kNoField);
00692 
00693   // The following regions in the main detector but outside the steel
00694   // and coil region will have no field or low field implemented
00695   SetMedium(Geo::kStpScint,   "PSTYRENE SCINT",    Geo::kLowField);
00696   SetMedium(Geo::kStpTiO2,    "COEX TIO2 PSTYRENE",Geo::kLowField);
00697   SetMedium(Geo::kMdlAlSkin,  "ALUM",              Geo::kLowField);
00698   SetMedium(Geo::kMdlAir,     "AIR",               Geo::kLowField);
00699   SetMedium(Geo::kPlnScint,   "AIR",               Geo::kLowField);
00700   SetMedium(Geo::kPlnAirGap,  "AIR",               Geo::kLowField);
00701 
00702   // The following regions in the steel and in the coil region have a
00703   // strong field implemented
00704   SetMedium(Geo::kPlnSteel,   "FEPL",        Geo::kHighField); // steel pln
00705   SetMedium(Geo::kCRGapWater, "WATER",       Geo::kHighField); // air gap CR
00706   SetMedium(Geo::kCRGapCoil,  "ALUM",        Geo::kHighField); 
00707   SetMedium(Geo::kCRGapThroat,"AIR",         Geo::kHighField); 
00708   SetMedium(Geo::kCRGapFlange,"IRON",        Geo::kHighField);
00709   SetMedium(Geo::kCRGapBypass,"AIR",         Geo::kHighField);
00710   SetMedium(Geo::kCRStlWater, "WATER",       Geo::kHighField); // steel pln CR
00711   SetMedium(Geo::kCRStlCoil,  "ALUM",        Geo::kHighField); 
00712   SetMedium(Geo::kCRStlThroat,"AIR",         Geo::kHighField);
00713   SetMedium(Geo::kCRStlNeck,  "IRON",        Geo::kHighField);
00714   SetMedium(Geo::kCRStlHole,  "AIR",         Geo::kHighField);
00715   SetMedium(Geo::kCRStlDetail,"FEPL",        Geo::kHighField);
00716   SetMedium(Geo::kCRSctWater, "WATER",       Geo::kHighField); // scint pln CR
00717   SetMedium(Geo::kCRSctCoil,  "ALUM",        Geo::kHighField); 
00718   SetMedium(Geo::kCRSctThroat,"AIR",         Geo::kHighField);
00719   SetMedium(Geo::kCRSctFlange,"IRON",        Geo::kHighField);
00720   SetMedium(Geo::kCRSctBypass,"AIR",         Geo::kHighField);
00721   
00722 }

void GeoMediumMap::BuildSwimMethodMap (   )  [private]
 

Definition at line 559 of file GeoMediumMap.cxx.

References Geo::AsString(), fSwimMethodMap, Registry::Get(), CfgConfigurable::GetConfig(), UgliLoanPool::Instance(), and MSG.

Referenced by BuildMediumMap().

00559                                       {
00560   // Private method to build swim method map for given validity context
00561 
00562   // Fill map with default values
00563   fSwimMethodMap[Geo::kNoField]   = Geo::kNoFieldSwim;
00564   fSwimMethodMap[Geo::kLowField]  = Geo::kNoFieldSwim;
00565   fSwimMethodMap[Geo::kHighField] = Geo::kRungeKutta;
00566   
00567   // Override with UgliLoanPool configuration as appropriate
00568   const Registry& r = UgliLoanPool::Instance()->GetConfig();
00569   Int_t tmpi;
00570   if ( r.Get("SwimMethodLowField",tmpi) ) {
00571     Geo::ESwimMethod swimmethod = (Geo::ESwimMethod)tmpi;
00572     if ( swimmethod != fSwimMethodMap[Geo::kLowField] ) {
00573       MSG("Geo",Msg::kInfo) << "SwimMethod for components w/field strength "
00574                             << Geo::AsString(Geo::kLowField) << " set to " 
00575                             << Geo::AsString(swimmethod) 
00576                             << " overriding default " 
00577                             << Geo::AsString(fSwimMethodMap[Geo::kLowField]) 
00578                             << "." << endl;
00579       fSwimMethodMap[Geo::kLowField]  = swimmethod;
00580     }
00581   }
00582   
00583   if ( r.Get("SwimMethodHighField",tmpi) ) {
00584     Geo::ESwimMethod swimmethod = (Geo::ESwimMethod)tmpi;
00585     if ( swimmethod != fSwimMethodMap[Geo::kHighField] ) {
00586       MSG("Geo",Msg::kInfo) << "SwimMethod for components w/field strength "
00587                             << Geo::AsString(Geo::kHighField) << " set to " 
00588                             << Geo::AsString(swimmethod) 
00589                             << " overriding default " 
00590                             << Geo::AsString(fSwimMethodMap[Geo::kHighField]) 
00591                             << "." << endl;
00592       fSwimMethodMap[Geo::kHighField] = swimmethod;
00593     }
00594   }
00595   
00596 }

void GeoMediumMap::ConfigureMedium (  GeoMedium *  med  )  [private]
 

Definition at line 514 of file GeoMediumMap.cxx.

References find(), Registry::Get(), UtilMCFlag::GetCut(), UgliLoanPool::GetMediumRegistry(), UtilMCFlag::GetProcess(), UtilMCFlag::GetTracking(), UgliLoanPool::Instance(), and MSG.

Referenced by BuildMediums(), and CreateMediumsforMaterial().

00514                                                  {
00515   // Private method to check UgliLoanPool registry for user specified medium
00516   // definition values that override default.
00517   
00518    std::string medName[2];
00519   
00520    medName[1] = med->GetName(); // specific name
00521    medName[0] = medName[1].substr(0,medName[1].find("_B")); // base name
00522 
00523    // Check UgliLoanPool registry for user specified medium definition values
00524    // that override default.
00525    for ( int i = 0; i < 2; i++ ) {
00526      // base name first, specific name second so that specific name config
00527      // will override that of base name if both present and overlapping.
00528      Registry medConfig 
00529             = UgliLoanPool::Instance()->GetMediumRegistry(medName[i].c_str());
00530    
00531      Registry::RegistryKey keyItr(&medConfig);
00532      while ( const char* newKey = keyItr() ) {
00533        Double_t tmpd;
00534        medConfig.Get(newKey,tmpd);
00535        UtilMCFlag::EProcess process = UtilMCFlag::GetProcess(newKey);
00536        if ( process != UtilMCFlag::kUnknownProcess ) 
00537                                       med -> SetProcess(process,(int)tmpd);
00538        else {
00539          UtilMCFlag::ECut cut = UtilMCFlag::GetCut(newKey);
00540          if ( cut != UtilMCFlag::kUnknownCut ) med -> SetCut(cut,tmpd);
00541          else {
00542            UtilMCFlag::ETracking trk = UtilMCFlag::GetTracking(newKey);
00543            if ( trk != UtilMCFlag::kUnknownTracking ) 
00544              med -> SetTracking(trk,tmpd);
00545            else {
00546              MSG("Geo",Msg::kWarning) << "Unknown medium config key " 
00547                                       << newKey << " for medium " 
00548                                       << med->GetName() << ". Ignored!" 
00549                                       << endl;
00550            }
00551          }
00552        }
00553      }  
00554    }
00555    
00556 }

int GeoMediumMap::CreateMediumsforMaterial (  std::string  medname,
int  medId,
int  matId,
int  isVol,
float  fieldm
)  [private]
 

Definition at line 441 of file GeoMediumMap.cxx.

References ConfigureMedium().

Referenced by BuildMediums().

00442                                                                     {
00443    // Create 3 Mediums for given Material w/Id matId:
00444    //   1)medbasename_B0 =>No field
00445    //   2)medbasename_B1 =>Swim with Runge-Kutta method (high gradient field)
00446    //   3)medbasename_B2 =>Swim with Stepwise-Helix method (low gradient field)
00447    // Mediums will be assigned Id's incrementally beginning with input medId.
00448    // Argument isVol and fieldM are used to define the medium sensitivity
00449    // and max BField respectively.
00450    // Return value is the last medId assigned to a created medium.
00451 
00452    // TGeoMedium is defined with arguments:
00453    //            medName,medId,matId,
00454    //            isVol  (Sensitive volume flag, set 0 if not sensitive)
00455    //            iField (User defined magnetic field, set
00456    //                    0, if no magnetic field
00457    //                    1, tracking performed with GRKUTA 
00458    //                       (use for strongly inhomogeneous field)
00459    //                    2, tracking performed with GHELIX
00460    //                       (use for inhomogeneous field)
00461    //                    3, tracking performed with GHELX3
00462    //                       (use for uniform magnetic field along z axis)
00463    //            fieldM (Max field value (in kGauss)),
00464    //            tMaxFd (Max angle due to field deflection in one step (deg)),
00465    //            steMax (Max step allowed (cm)),
00466    //            deeMax (Max fractional energy loss in a step),
00467    //            epsil  (Boundary crossing precision (cm)),
00468    //            stMin  (Minimum step due to energy loss, multiple scattering,
00469    //                    Cerenkov or B-fields (cm))
00470 
00471    // The following 4 values will be automatically computed by Geant3 when 
00472    // Auto configuration parameter set to 1 (default).
00473    // Even if the user sets Auto parameter to 0, negative values will still be
00474    // computed automatically.
00475    // See CONS210 section of Geant3 manual. 
00476    Float_t tMaxFd = -1.;   
00477    Float_t steMax = -1.;
00478    Float_t deeMax = -1.;
00479    Float_t  stMin = -1.;
00480 
00481    Float_t epsil       = +0.0001;
00482    Float_t field_epsil = +0.01; // used for all magnetized mediums
00483 
00484     // Non-magnetized medium 
00485    std::string medname;
00486    GeoMedium* med = 0;
00487    
00488    medname  = medbasename + "_B" +UtilString::ToString<int>(Geo::kNoFieldSwim);
00489    med = new GeoMedium(medname.c_str(),medId,matId,isVol, Geo::kNoFieldSwim,
00490                                   fieldM,tMaxFd,steMax,deeMax,epsil,stMin);
00491    ConfigureMedium(med);
00492 
00493    medId++;
00494    
00495    // Magnetized aluminium medium treated as strongly inhomogeneous by swimmer
00496    medname = medbasename + "_B" + UtilString::ToString<int>(Geo::kRungeKutta);
00497    med = new GeoMedium(medname.c_str(),medId,matId,isVol,Geo::kRungeKutta,
00498                        fieldM,tMaxFd,steMax,deeMax,field_epsil,stMin);
00499    ConfigureMedium(med);
00500    
00501    medId++;
00502    
00503    // Magnetized aluminium medium treated as inhomogeneous by swimmer
00504    medname = medbasename + "_B" + UtilString::ToString<int>(Geo::kStepHelix);
00505    med = new GeoMedium(medname.c_str(),medId,matId,isVol,Geo::kStepHelix,
00506                  fieldM,tMaxFd,steMax,deeMax,field_epsil,stMin);
00507    ConfigureMedium(med);
00508    
00509    return medId;
00510    
00511 }

Geo::EFldStrength GeoMediumMap::GetFldStrength (  Geo::EDetComponent  detcomp  )  const [virtual]
 

Definition at line 72 of file GeoMediumMap.cxx.

References Geo::AsString(), fFldStrengthMap, FldStrengthMapConstItr, and MSG.

Referenced by Print().

00073                                                                           {
00074   // Get field strength corresponding to detector component
00075 
00076   FldStrengthMapConstItr citr = fFldStrengthMap.find(detcomp);
00077   if ( citr == fFldStrengthMap.end() ) {
00078     MSG("Geo",Msg::kWarning) << "GeoMediumMap::GetFldStrength unable to find "
00079                              << "field strength for detcomponent " 
00080                              << Geo::AsString(detcomp) << "." << endl;
00081     return Geo::kUnknownFldStrength;
00082   }
00083   
00084   return citr->second;
00085   
00086 }

GeoMedium * GeoMediumMap::GetMedium (  Geo::EDetComponent  detcomp  )  const [virtual]
 

Definition at line 56 of file GeoMediumMap.cxx.

References Geo::AsString(), fMediumMap, MediumMapConstItr, and MSG.

Referenced by GeoScintMdlVolume::AddAirNode(), GeoStripVolume::AddPstyreneNodes(), GeoGeometry::BuildFarCoil(), GeoGeometry::BuildFarCoilAirGapVolume(), GeoSteelPlnVolume::BuildFarCoilVolume(), GeoScintPlnVolume::BuildFarCoilVolume(), GeoGeometry::BuildFarLeadStacks(), GeoGeometry::BuildFarMARS(), GeoGeometry::BuildGeometry(), GeoGeometry::BuildNearCoil(), GeoGeometry::BuildNearCoilAirGapVolume(), GeoSteelPlnVolume::BuildNearCoilVolume(), GeoScintPlnVolume::BuildNearCoilVolume(), GeoGeometry::BuildNearMARS(), GeoShieldGroup::BuildNode(), GeoGeometry::BuildPlanePairVolumes(), GeoScintMdlVolume::GeoScintMdlVolume(), GeoScintPlnVolume::GeoScintPlnVolume(), GeoStripVolume::GeoStripVolume(), and GeoGeometry::ls().

00056                                                                  {
00057   // Get medium corresponding to detector component
00058 
00059   MediumMapConstItr citr = fMediumMap.find(detcomp);
00060   if ( citr == fMediumMap.end() ) {
00061     MSG("Geo",Msg::kWarning) << "GeoMediumMap::GetMedium unable to find "
00062                              << "medium for detcomponent " 
00063                              << Geo::AsString(detcomp) << "." << endl;
00064     return (GeoMedium*)0;
00065   }
00066   
00067   return const_cast<GeoMedium*>(citr->second);
00068   
00069 }

virtual Geo::ESwimMethod GeoMediumMap::GetSwimMethod (  Geo::EFldStrength  fldstrength  )  const [inline, virtual]
 

Definition at line 47 of file GeoMediumMap.h.

References fSwimMethodMap.

Referenced by Print(), and SetMedium().

00048                          { return fSwimMethodMap.find(fldstrength)->second; }

void GeoMediumMap::Print (  Option_t *  option = ""  )  const [virtual]
 

Definition at line 404 of file GeoMediumMap.cxx.

References Geo::AsString(), fMediumMap, GetFldStrength(), GetSwimMethod(), and MediumMapConstItr.

Referenced by GeoGeometry::DumpVolume(), and GeoGeometry::ls().

00404                                                      {
00405   // Print medium name, swim method associated with each detector
00406   // component
00407 
00408   MediumMapConstItr citr;
00409   cout << setiosflags(ios::left)
00410        << setw(15) << "DetComponent"
00411        << setw(30) << "Medium"
00412        << setw(15) << "FldStrength"
00413        << setw(15) << "SwimMethod"
00414        << endl;
00415   cout << setiosflags(ios::left) 
00416        << setfill('-') << setw(12) << "-" 
00417        << setfill(' ') << setw(3) << " "
00418        << setfill('-') << setw(6) << "-" 
00419        << setfill(' ') << setw(24) << " "
00420        << setfill('-') << setw(11) << "-" 
00421        << setfill(' ') << setw(4) << " "
00422        << setfill('-') << setw(10) << "-" 
00423        << setfill(' ') << setw(5) << " "
00424        << endl;
00425   
00426   for (citr = fMediumMap.begin(); citr != fMediumMap.end(); citr++ ) {
00427     Geo::EFldStrength fldstrength = GetFldStrength(citr->first);
00428     Geo::ESwimMethod swimmethod = GetSwimMethod(fldstrength);
00429     
00430     cout << setiosflags(ios::left) << setfill(' ')
00431          << setw(15) << Geo::AsString(citr->first)
00432          << setw(30) << citr->second->GetName()
00433          << setw(15) << Geo::AsString(fldstrength)
00434          << setw(15) << Geo::AsString(swimmethod) 
00435          << endl;
00436   }
00437   
00438 }

void GeoMediumMap::SetMedium (  Geo::EDetComponent  ,
std::string  medname,
Geo::EFldStrength 
)  [private]
 

Definition at line 760 of file GeoMediumMap.cxx.

References Geo::AsString(), fFldStrengthMap, fMediumMap, UgliLoanPool::GetMedium(), GetSwimMethod(), UgliLoanPool::Instance(), and MSG.

Referenced by BuildCalMediumMap(), BuildDefMediumMap(), BuildFarMediumMap(), and BuildNearMediumMap().

00762                                                           {
00763   // Private method to place medium of requested type in fMediumMap
00764   // with key detcomp.  
00765 
00766   Geo::ESwimMethod swimmethod = GetSwimMethod(fldstrength);
00767   
00768   std::string usermedname = UgliLoanPool::Instance()->GetMedium(detcomp);  
00769   if (!usermedname.empty()) {
00770     MSG("Geo",Msg::kInfo) << "Medium for component "
00771                           << Geo::AsString(detcomp) << " set to " 
00772                           << usermedname.c_str() << " overriding default " 
00773                           << medbasename.c_str() << "." << endl;
00774     medbasename = usermedname;
00775   }
00776   
00777   std::string medname = medbasename + "_B" 
00778                       + UtilString::ToString<int>(swimmethod);
00779   GeoMedium* medium 
00780           = dynamic_cast<GeoMedium*>(gGeoManager->GetMedium(medname.c_str()));
00781   if ( !medium ) {
00782     MSG("Geo",Msg::kError) << "GeoMediumMap::SetMedium failed to find "
00783                            << "medium of name " << medname.c_str() 
00784                            << "\nfor component " << Geo::AsString(detcomp)
00785                            << ". Abort." << endl;
00786     abort();
00787   }
00788 
00789   fMediumMap[detcomp] = medium;
00790   fFldStrengthMap[detcomp] = fldstrength;
00791   
00792 }

void GeoMediumMap::UpdateGlobalManager (   )  const [virtual]
 

Definition at line 48 of file GeoMediumMap.cxx.

References fGeoGeometry.

Referenced by BuildMediums().

00048                                              {
00049 
00050   if ( fGeoGeometry ) fGeoGeometry -> UpdateGlobalManager();
00051   else gGeoManager = 0;
00052   
00053 }

Friends And Related Function Documentation

friend class GeoGeometry [friend]
 

Definition at line 25 of file GeoMediumMap.h.

Member Data Documentation

FldStrengthMap GeoMediumMap::fFldStrengthMap [private]
 

Definition at line 79 of file GeoMediumMap.h.

Referenced by GetFldStrength(), and SetMedium().

GeoGeometry* GeoMediumMap::fGeoGeometry [private]
 

Definition at line 76 of file GeoMediumMap.h.

Referenced by GeoMediumMap(), and UpdateGlobalManager().

MediumMap GeoMediumMap::fMediumMap [private]
 

Definition at line 78 of file GeoMediumMap.h.

Referenced by GetMedium(), Print(), and SetMedium().

SwimMethodMap GeoMediumMap::fSwimMethodMap [private]
 

Definition at line 80 of file GeoMediumMap.h.

Referenced by BuildSwimMethodMap(), and GetSwimMethod().

VldContext GeoMediumMap::fVldContext [private]
 

reference link to geometry creator

Definition at line 77 of file GeoMediumMap.h.

Referenced by BuildMediumMap(), and BuildMediums().

The documentation for this class was generated from the following files:
Generated on Mon Feb 15 11:09:14 2010 for loon by  doxygen 1.3.9.1