#include "GaudiKernel/MsgStream.h"
 #include "AthenaKernel/getMessageSvc.h"
 #include "MuonGeoModel/MuonDetectorFactory001.h"
 
 #include "RDBAccessSvc/IRDBAccessSvc.h"
 #include "RDBAccessSvc/IRDBRecord.h"
 #include "RDBAccessSvc/IRDBRecordset.h"
 
 #include "MuonGeoModel/MYSQL.h"
 #include "MuonGeoModel/FPVMAP.h"
 #include "MuonGeoModel/MuonSystemDescription.h"
 #include "MuonGeoModel/StationSelector.h"
 #include "MuonGeoModel/Station.h"
 #include "MuonGeoModel/MuonChamber.h"
 #include "MuonReadoutGeometry/GenericCSCCache.h"
 #include "MuonReadoutGeometry/GenericMDTCache.h"
 #include "MuonReadoutGeometry/GenericRPCCache.h"
 #include "MuonReadoutGeometry/GenericTGCCache.h"
 #include "MuonGeoModel/ArrayFunction.h"
 #include "MuonReadoutGeometry/MuonStation.h"
 #include "MuonGeoModel/BarrelToroidBuilderRDB.h"
 #include "MuonGeoModel/EndCapToroidBuilderRDB.h"
 #include "MuonGeoModel/FeetToroidBuilderRDB.h"
 #include "MuonGeoModel/ShieldBuilderRDB.h"
 #include "MuonGeoModel/CalorimeterSaddleBuilder.h"
 
 #include "IdDictDetDescr/IdDictManager.h" 
 #include "MuonIdHelpers/MdtIdHelper.h"
 #include "MuonIdHelpers/RpcIdHelper.h"
 #include "MuonIdHelpers/TgcIdHelper.h"
 #include "MuonIdHelpers/CscIdHelper.h"
 
 #include "GeoModelKernel/GeoBox.h"
 #include "GeoModelKernel/GeoTube.h"
 #include "GeoModelKernel/GeoPcon.h"
 #include "GeoModelKernel/GeoTrd.h"
 #include "GeoModelKernel/GeoTrap.h"
 #include "GeoModelKernel/GeoPgon.h"
 #include "GeoModelKernel/GeoMaterial.h"
 #include "GeoModelKernel/GeoLogVol.h"
 #include "GeoModelKernel/GeoPhysVol.h"
 #include "GeoModelKernel/GeoFullPhysVol.h"
 #include "GeoModelKernel/GeoTransform.h"
 #include "GeoModelKernel/GeoAlignableTransform.h"
 #include "GeoModelKernel/GeoNameTag.h"
 #include "GeoModelKernel/GeoShapeShift.h"
 #include "GeoModelKernel/GeoShapeUnion.h"
 #include "GeoModelKernel/GeoShapeSubtraction.h"
 #include "GeoModelKernel/GeoSerialTransformer.h" 
 #include "GeoModelKernel/GeoIdentifierTag.h"
 #include "GeoModelKernel/GeoPerfUtils.h"
 #include "GeoModelSvc/StoredMaterialManager.h"
 
 #include "StoreGate/StoreGateSvc.h"
 
 #include "CLHEP/GenericFunctions/Variable.hh"
 
 #include "MuonGeoModel/DBReader.h"
 #include "MuonGeoModel/RDBReaderAtlas.h"
 
 #include <stdexcept>
 #include <vector>
 #include <iomanip>
 #include <sstream>
 #include <fstream>
 typedef std::stringstream  my_sstream;
 typedef std::ostringstream my_osstream;
 
 // The objects for mapping plane indexes in MuonSystem to the record index in RDBRecordset
 typedef std::map<int, unsigned int, std::less<int> > muonsysIndMap;
 
 using namespace Genfun;
 using namespace GeoXF;
 
 #define skip_chambers  false
 #define skip_toroids   false
 #define skip_shielding false
 #define skip_caloSaddle false
 #define useAssemblies  false
 
 
 namespace MuonGM {
 
 MuonDetectorFactory001::MuonDetectorFactory001(StoreGateSvc* pDetStore) 
   : m_rdb(1), m_muon(NULL), m_manager(NULL), m_pDetStore(pDetStore),
     m_pRDBAccess(0), m_altAsciiDBMap(0)
 {
   MsgStream log(Athena::getMessageSvc(), "MuonGeoModel");
   m_muon = new MuonSystemDescription( "MuonSystem" );
   m_muon->barrelInnerRadius =  4.30*m;
   m_muon->innerRadius       =  0.07*m;
   m_muon->outerRadius       = 13.00*m;
   m_muon->endcapFrontFace   =  6.74*m;
   m_muon->length            = 22.03*m;
   m_muon->barreLength       =  6.53*m; 
   m_muon->barrelInterRadius =  3.83*m;
   m_muon->extraZ = 12.9*m;
   m_muon->extraR = 12.5*m;
 
   m_selectedStations = std::vector<std::string>(0);
   m_selectedStEta    = std::vector<int>(0);
   m_selectedStPhi    = std::vector<int>(0);
 
   m_enableFineClashFixing = 0;
 
   m_switchOnOff_BUILDINERTMATERIALS = 0;
   m_switchOnOff_MINIMALGEO          = 0;
   m_switchOnOff_BUILDENDCAP         = 0;
   m_switchOnOff_BUILDCALOSADDLE     = 0;
   m_switchOnOff_BUILDBARRELTOROID   = 0;
   m_switchOnOff_BUILDENDCAPTOROID   = 0;
   m_switchOnOff_BUILDFEET           = 0;
   m_switchOnOff_BUILDDISKSHIELD     = 0;
   m_switchOnOff_BUILDTOROIDSHIELD   = 0;
   m_switchOnOff_BUILDFORWARDSHIELD  = 0;
   
   log<<MSG::INFO<<"MuonDetectorFactory - constructor "<<" MuonSystem OuterRadius "<< m_muon->outerRadius
                                          <<" Length "<< m_muon->length <<endreq;
   //std::cerr<<"MuonDetectorFactory - constructor/// size of vectors "<<m_selectedStations.size()<<" "<<m_selectedStEta.size()<<" "<<m_selectedStPhi.size()<<std::endl;
 }
 
 MuonDetectorFactory001::~MuonDetectorFactory001() 
 {
     delete m_muon;
 }
 
 const MuonDetectorManager* MuonDetectorFactory001::getDetectorManager() const 
 {
     return m_manager;
 }
 
 void MuonDetectorFactory001::create( GeoPhysVol* world )
 {
     MsgStream log(Athena::getMessageSvc(), "MuGM:MuonFactory");
 
     std::ofstream geoModelStats("MuonGeoModelStatistics_MuonDetectorFactory");
     int mem  = GeoPerfUtils::getMem();
     int cpu  = int(GeoPerfUtils::getCpu()/100.);
     
        
     geoModelStats <<"At MuonDetectorFactory::create entry point: \t SZ= " <<mem << " Kb \t Time = " << cpu << " seconds " << std::endl; 
 
     int umem = GeoPerfUtils::getMem();
     int ucpu = int(GeoPerfUtils::getCpu()/100.);
     geoModelStats <<"At MuonDetectorFactory::resetting to 0:     \t SZ= " <<umem-mem << " Kb \t Time = " << ucpu-cpu << " seconds " << std::endl;
     mem = umem;
     cpu = ucpu;
     
     
     if (!m_manager)  m_manager = new MuonDetectorManager();
     // std::cout<<" MuonDetectorFactory001::create m_layout = <"<<m_layout<<">"<<std::endl;
     
     // check consistency of flags coming from the tool
     if (m_layout.substr(0,1) != "P" && m_layout.substr(0,3) != "CTB") 
     {
 //         if (m_rdb == 0) 
 //         {
 //             log<<MSG::WARNING<<"Muon Layouts of type Q and following are available only via Oracle"<<endreq;
 //             log<<MSG::WARNING<<"                       => overwriting UseRDB flag"<<endreq;
 //             m_rdb = 1;
 //         }
         if (m_layout == "Q02_initial") 
         {
             m_includeCutouts = 0;
             m_includeCutoutsBog = 0;
             log<<MSG::INFO<<"MuonLayout set to <"<<m_layout<<"> = Preliminary version for Rome workshop "<<endreq;
             log<<MSG::INFO<<"                   BOG chambers are shorter; no cutouts implemented"<<endreq;
         }            
         if (m_layout == "Q02_initial_pro") 
         {
             m_includeCutouts = 0;
             m_includeCutoutsBog = 1;
             log<<MSG::INFO<<"MuonLayout set to <"<<m_layout<<"> = Production version for Rome workshop "<<endreq;
             log<<MSG::INFO<<"                   BOG cutouts are activated, all other cutouts are disabled"<<endreq;
             m_layout = "Q02_initial";
             log<<MSG::INFO<<"                   Setting internal Layout Name to "<<m_layout<<endreq;
             log<<MSG::INFO<<"                           includeCutouts and includeCutoutsBog to "
                <<m_includeCutouts<<" "
                <<m_includeCutoutsBog <<endreq;
         }            
         if (m_layout == "Q02") 
         {
             m_includeCutouts = 0;
             m_includeCutoutsBog = 1;
             log<<MSG::INFO<<"MuonLayout set to <"<<m_layout<<"> = Production version for Rome workshop "<<endreq;
             log<<MSG::INFO<<"                   BOG cutouts are activated, all other cutouts are disabled"<<endreq;
             log<<MSG::INFO<<"                   Setting includeCutouts and includeCutoutsBog to "
                <<m_includeCutouts<<" "
                <<m_includeCutoutsBog <<endreq;
         }            
         if (m_layout.substr(0,1) == "R") 
         {
             m_includeCutouts = 1;
             m_includeCutoutsBog = 1;
             log<<MSG::INFO<<"MuonLayout set to <"<<m_layout<<"> = Development version for DC3 - infrastructures "
                <<endreq;
             log<<MSG::INFO<<"                   BOG cutouts are activated "<<m_includeCutoutsBog
                <<" , all other cutouts are disabled "<<m_includeCutouts<<endreq;
         }            
         if (m_layout.substr(0,3) == "CTB") 
         {
             log<<MSG::INFO<<"MuonLayout set to <"<<m_layout<<"> = 2004 Combined Testbeam "<<endreq;
             if (m_includeCtbBis)
               log<<MSG::INFO<<" The BIS (or BEE) chamber will be built"<<endreq;
             else
               log<<MSG::INFO<<" The BIS (or BEE) chamber will NOT be built (this is the default)."<<endreq;
         } 
     }
 
     m_manager->setCachingFlag(m_caching);
     m_manager->setCacheFillingFlag(m_cacheFillingFlag);
     m_manager->setGeometryVersion(m_layout);
     m_manager->set_DBMuonVersion(m_DBMuonVersion);
     log<<MSG::INFO<<"Manager created for geometry version "
        <<m_manager->geometryVersion()<<" from DB MuonVersion <"<<m_manager->get_DBMuonVersion()<<">"<<endreq;
   
     // here create the MYSQL singleton and assign to it the geometry version
     MYSQL *mysql=  MYSQL::GetPointer(); 
     mysql->setGeometryVersion(m_layout);
     mysql->set_amdb_from_RDB(m_rdb == 1);
     mysql->set_DBMuonVersion(m_DBMuonVersion);
     log<<MSG::INFO<<"Mysql helper class created here for geometry version "
        <<mysql->getGeometryVersion()<<" from DB MuonVersion <"<<mysql->get_DBMuonVersion()<<">"<<endreq;
         
   
     StatusCode sc =StatusCode::SUCCESS;
 
 //     if (m_idhfromconverters != 0)
 //     {
 //         const DataHandle<MdtIdHelper>  mdtidh;
 //         sc = m_pDetStore->retrieve(mdtidh,"MDTIDHELPER");
 //         if (sc.isFailure())log<<MSG::ERROR<<" not found MDT "<<endreq;
 //         m_manager->set_mdtIdHelper(mdtidh);
 //         const DataHandle<RpcIdHelper> rpcidh;
 //         sc = m_pDetStore->retrieve(rpcidh,"RPCIDHELPER");
 //         if (sc.isFailure() )log<<MSG::ERROR<<" not found RPC "<<endreq;
 //         m_manager->set_rpcIdHelper(rpcidh);
 //         const DataHandle<TgcIdHelper> tgcidh;
 //         sc = m_pDetStore->retrieve(tgcidh,"TGCIDHELPER");
 //         if (sc.isFailure() )log<<MSG::ERROR<<" not found TGC "<<endreq;
 //         m_manager->set_tgcIdHelper(tgcidh);
 //         const DataHandle<CscIdHelper> cscidh;
 //         sc = m_pDetStore->retrieve(cscidh,"CSCIDHELPER");
 //         if (sc.isFailure() )log<<MSG::ERROR<<" not found CSC "<<endreq;
 //         m_manager->set_cscIdHelper(cscidh);
 //     }
 //     else 
 //     {
     // MdtIdHelper
     bool mdtidhInitialized=false;
     MdtIdHelper *mdtidh = new MdtIdHelper;
     const IdDictManager * idDictMgr = 0; 
     sc = m_pDetStore->retrieve(idDictMgr, "IdDict");
     if (sc.isFailure()) {
       log<<MSG::ERROR << " Could not get IdDictManager !" << endreq;
       throw std::runtime_error("Error in MuonDetectorFactory, could not get IdDictManager");
     }
     
     
     //  if (StatusCode::SUCCESS == sc) {
     if (idDictMgr) {
       if (!idDictMgr->initializeHelper(*mdtidh)) { // Returns 1 if there is a problem
         mdtidhInitialized=true;
         log<<MSG::INFO << " MdtIdHelper has been initialised! "
            << endreq;
       }
       else 
       {
         log<<MSG::WARNING<<" IdDictManager found BUT initializeHelper ="
            <<idDictMgr->initializeHelper(*mdtidh)<<endreq;
       }
     }
     else log<<MSG::WARNING<<" IdDictManager not found in the Detector Store"<<endreq;
     //  }
     //  else log<<MSG::ERROR<<" FAILURE:: IdDictManager not found in the Detector Store"
     //<<endreq;
     if (!mdtidhInitialized) {
       log<<MSG::ERROR << " Cannot initialize MdtIdHelper ! "
          << endreq;
       delete mdtidh;
       mdtidh=NULL;
       throw std::runtime_error("Error in MuonDetectorFactory, cannot initialize MdtIdHelper");
     }
     m_manager->set_mdtIdHelper(mdtidh);
     
     // CscIdHelper
     bool cscidhInitialized=false;
     CscIdHelper *cscidh = new CscIdHelper;
     if (!idDictMgr->initializeHelper(*cscidh)) { // Returns 1 if there is a problem
       cscidhInitialized=true;
       log<<MSG::INFO << " CscIdHelper has been initialised! "
          << endreq;
     }
     if (!cscidhInitialized) {
       log<<MSG::ERROR << " Cannot initialize CscIdHelper ! " << endreq;
       delete cscidh;
       cscidh=NULL;
       throw std::runtime_error("Error in MuonDetectorFactory, cannot initialize CscIdHelper");
       return;
     }  
     m_manager->set_cscIdHelper(cscidh);
   
     // RpcIdHelper
     bool rpcidhInitialized=false;
     RpcIdHelper *rpcidh = new RpcIdHelper;
     if (!idDictMgr->initializeHelper(*rpcidh)) { // Returns 1 if there is a problem
       rpcidhInitialized=true;
       log<<MSG::INFO << " RpcIdHelper has been initialised! " << endreq;
     }
     if (!rpcidhInitialized) {
       log<<MSG::ERROR << " Cannot initialize RpcIdHelper ! " << endreq;
       delete rpcidh;
       rpcidh=NULL;
       throw std::runtime_error("Error in MuonDetectorFactory, cannot initialize RpcIdHelper");
       return;
     }  
     m_manager->set_rpcIdHelper(rpcidh);
 
     // TgcIdHelper
     bool tgcidhInitialized=false;
     TgcIdHelper *tgcidh = new TgcIdHelper;
     if (!idDictMgr->initializeHelper(*tgcidh)) { // Returns 1 if there is a problem
       tgcidhInitialized=true;
       log<<MSG::INFO << " TgcIdHelper has been initialised! " << endreq;
     }
     if (!tgcidhInitialized) {
       log<<MSG::ERROR << " Cannot initialize TgcIdHelper ! " << endreq;
       delete tgcidh;
       tgcidh=NULL;
       throw std::runtime_error("Error in MuonDetectorFactory, cannot initialize TgcIdHelper");
       return;
     }  
     m_manager->set_tgcIdHelper(tgcidh);
     //}
   
 
     umem = GeoPerfUtils::getMem();
     ucpu = int(GeoPerfUtils::getCpu()/100.);
     geoModelStats <<"At MuonDetectorFactory::IdHelpers loaded    \t SZ= " <<umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = "<<umem-mem<<" \t Delta T ="<<ucpu - cpu << std::endl;
     mem = umem;
     cpu = ucpu;
     
 
 
     log<<MSG::INFO<<" **************** MuonDetectorFactory001 ************************"<<endreq;
     log<<  " *** Start building the Muon Geometry Tree **********************"<<endreq;
 
     DBReader* dbr = NULL;
     std::string OracleTag =  m_DBkey;
     std::string OracleNode = m_DBnode;
     if      (m_layout.substr(0,3) == "P03")     {
         // DC1 and DC2
         // OracleTag = "ATLAS-00";
         dbr = new RDBReaderAtlas(m_pDetStore, m_pRDBAccess, OracleTag, OracleNode);
 //         else
 //         {
 //             //ss 21/02/2007 breaking all dependencies from NOVA
 //             // dbr = new  DBReaderAtlasP(m_pDetStore);
 //             log<<MSG::ERROR<<"Layout P from NOVA is NOT supported after 21/02/2007 and MuonGeoModel tag >= 00-04-01"<<endreq;
 //             return;
 //         }
     }
     else if (m_layout.substr(0,11) == "Q02_initial" && m_includeCutoutsBog == 0) {
         // Preliminary Rome ws version
         // OracleTag = "ATLAS-Rome-Initial-01";
         dbr = new RDBReaderAtlas(m_pDetStore, m_pRDBAccess, OracleTag, OracleNode);
     }
     else if (m_layout.substr(0,11) == "Q02_initial" && m_includeCutoutsBog == 1) {
         // Production Rome ws version 
         // OracleTag = "ATLAS-Rome-Initial-02";
         dbr = new RDBReaderAtlas(m_pDetStore, m_pRDBAccess, OracleTag, OracleNode);
     }
     else if (m_layout == "Q02" || m_layout.substr(0,1) == "R" )       {
         // Production Rome Final
         // OracleTag = "ATLAS-Rome-Final-00";
         //dbr = new RDBReaderAtlas(m_pDetStore, m_pRDBAccess, OracleTag, OracleNode);
 
         log<<MSG::DEBUG<<"calling RDBReaderAtlas with m_altAsciiDBMap"<<endreq;
         dbr = new RDBReaderAtlas(m_pDetStore, m_pRDBAccess, OracleTag, OracleNode, m_altAsciiDBMap);
       
     }
     else if (m_layout == "CTB2004") {
         // dbr = new DBReaderTB04(m_pDetStore);
         log<<MSG::ERROR<<"Layout CTB2004 (existing only in NOVA) is NOT supported after 21/02/2007 and MuonGeoModel tag >= 00-04-01"<<endreq;
         log<<MSG::ERROR<<"For CTB studies, use AtlasRelease <13.0.0"<<endreq;
         return;
     }
     else
     {
         log << MSG::ERROR<<"Uninitialized DBReader; Muon node will not be built"<<endreq;
     }
 
     // 
     bool includeInertMaterials = true;
     bool minimalgeo            = false;
     bool buildEndcap           = true;
     bool buildBarrelToroid        = !skip_toroids;
     bool buildEndcapToroid        = !skip_toroids;
     //bool buildEndcapToroid        = false;
     bool buildFeet                = !skip_toroids;
     //bool buildFeet                = false;
     bool buildDiskShielding       = !skip_shielding;
     bool buildToroidShielding     = !skip_shielding;
     bool buildForwardShielding    = !skip_shielding;
     bool buildCaloSaddle          = !skip_caloSaddle;
     const IRDBRecordset* switchesRec = m_pRDBAccess->getRecordset("MuonSwitches", OracleTag, OracleNode);
     if( switchesRec->size()!=0 )
     {
       //
         const IRDBRecord *mySwitch = (*switchesRec)[0];
         if(!(mySwitch->isFieldNull("BUILDINERTMATERIALS")))
         {
             includeInertMaterials = (mySwitch->getInt("BUILDINERTMATERIALS")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: Overall Inert Materials are on/off "<<includeInertMaterials<<endreq;
             if ( m_switchOnOff_BUILDINERTMATERIALS>100 && (m_switchOnOff_BUILDINERTMATERIALS%1000) != includeInertMaterials) 
             {
               includeInertMaterials = m_switchOnOff_BUILDINERTMATERIALS%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR includeInertMaterials = "<<includeInertMaterials<<endreq;
             }
         }
         //
         if(!(mySwitch->isFieldNull("MINIMALGEO")))
         {
             minimalgeo = (mySwitch->getInt("MINIMALGEO")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: minimalgeo is "<<minimalgeo<<endreq;
             if ( m_switchOnOff_MINIMALGEO>100 && (m_switchOnOff_MINIMALGEO%1000) != minimalgeo) 
             {
               minimalgeo = m_switchOnOff_MINIMALGEO%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR minimalgeo = "<<minimalgeo<<endreq;
             }
         }
         //
         if(!(mySwitch->isFieldNull("BUILDENDCAP")))
         {
             buildEndcap = (mySwitch->getInt("BUILDENDCAP")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: EC chambers are on/off "<<buildEndcap<<endreq;
             if (m_switchOnOff_BUILDENDCAP>100 && (m_switchOnOff_BUILDENDCAP%1000) != buildEndcap)
             {
               buildEndcap = m_switchOnOff_BUILDENDCAP%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR buildEndcap = "<<buildEndcap<<endreq;
             }
             if (!buildEndcap) {
                 m_selectedStations.push_back("B");
             }
         }
         //
         if(!(mySwitch->isFieldNull("BUILDBARRELTOROID")))
         {
             buildBarrelToroid = (mySwitch->getInt("BUILDBARRELTOROID")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: Barrel Toroid is on/off "<<buildBarrelToroid<<endreq;
             if (m_switchOnOff_BUILDBARRELTOROID>100 && (m_switchOnOff_BUILDBARRELTOROID%1000) != buildBarrelToroid)
             {
               buildBarrelToroid = m_switchOnOff_BUILDBARRELTOROID%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR buildBarrelToroid = "<<buildBarrelToroid<<endreq;
             }
         }
         //
         if(!(mySwitch->isFieldNull("BUILDENDCAPTOROID")))
         {
             buildEndcapToroid = (mySwitch->getInt("BUILDENDCAPTOROID")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: Endcap Toroid is on/off "<<buildEndcapToroid<<endreq;
             if (m_switchOnOff_BUILDENDCAPTOROID>100 && (m_switchOnOff_BUILDENDCAPTOROID%1000) != buildEndcapToroid) 
             {
               buildEndcapToroid = m_switchOnOff_BUILDENDCAPTOROID%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR buildEndcapToroid = "<<buildEndcapToroid<<endreq;
             }
         }
         //
         if(!(mySwitch->isFieldNull("BUILDFEET")))
         {
             buildFeet = (mySwitch->getInt("BUILDFEET")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: Atlas Feet are on/off "<<buildFeet<<endreq;
             if (m_switchOnOff_BUILDFEET>100 && (m_switchOnOff_BUILDFEET%1000) != buildFeet)
             {
               buildFeet = m_switchOnOff_BUILDFEET%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR buildFeet = "<<buildFeet<<endreq;
             }
         }
         //
         if(!(mySwitch->isFieldNull("BUILDDISKSHIELD")))
         {
             buildDiskShielding = (mySwitch->getInt("BUILDDISKSHIELD")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: Disk Shielding is on/off "<<buildDiskShielding<<endreq;
             if (m_switchOnOff_BUILDDISKSHIELD>100 && (m_switchOnOff_BUILDDISKSHIELD%1000) != buildDiskShielding)
             {
               buildDiskShielding = m_switchOnOff_BUILDDISKSHIELD%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR buildDiskShielding = "<<buildDiskShielding<<endreq;
             }
         }
         //
         if(!(mySwitch->isFieldNull("BUILDTOROIDSHIELD")))
         {
             buildToroidShielding = (mySwitch->getInt("BUILDTOROIDSHIELD")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: Toroid Shielding is on/off "<<buildToroidShielding<<endreq;
             if (m_switchOnOff_BUILDTOROIDSHIELD>100 && (m_switchOnOff_BUILDTOROIDSHIELD%1000) != buildToroidShielding)
             {
               buildToroidShielding = m_switchOnOff_BUILDTOROIDSHIELD%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR buildToroidShielding = "<<buildToroidShielding<<endreq;
             }
         }
         //
         if(!(mySwitch->isFieldNull("BUILDFORWARDSHIELD")))
         {
             buildForwardShielding = (mySwitch->getInt("BUILDFORWARDSHIELD")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: Forward Shielding is on/off "<<buildForwardShielding<<endreq;
             if (m_switchOnOff_BUILDFORWARDSHIELD > 100 && (m_switchOnOff_BUILDFORWARDSHIELD%1000) != buildForwardShielding)
             {
               buildForwardShielding = m_switchOnOff_BUILDFORWARDSHIELD%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR buildForwardShielding = "<<buildForwardShielding<<endreq;
             }
         }
         //
         if(!(mySwitch->isFieldNull("BUILDCALOSADDLE")))
         {
             buildCaloSaddle = (mySwitch->getInt("BUILDCALOSADDLE")==0) ? false : true;
             log<<MSG::INFO<<"From std conf. in MUONSWITCHES: Calorimeter Saddle is on/off "<<buildCaloSaddle<<endreq;
             if (m_switchOnOff_BUILDCALOSADDLE > 100 && (m_switchOnOff_BUILDCALOSADDLE%1000) != buildCaloSaddle)
             {
               buildCaloSaddle  = m_switchOnOff_BUILDCALOSADDLE%1000;
               log<<MSG::INFO<<"Resetting std conf. for this Property: CUSTOM VALUE FOR buildCaloSaddle = "<<buildCaloSaddle<<endreq;
             }
         }
         else buildCaloSaddle = false;
     }
     
     // set here the flag defining the geometry granularity
     // minimalgeo = 1 => The geo tree is built up to the Detector Level (Full PhysVol)
     //                     no internal structure of the Detector is built
     // minimalgeo = 0 => The geo tree is built in full details 
     m_manager->setMinimalGeoFlag(minimalgeo);
     // set here the flag deciding whether to include cutouts:
     //m_includeCutouts = 1 => include cutouts
     //m_includeCutouts = 0 => no cutouts
     m_manager->setCutoutsFlag(m_includeCutouts);
     m_manager->setCutoutsBogFlag(m_includeCutoutsBog);
     mysql->setCutoutsBogFlag(m_includeCutoutsBog);
     mysql->setCtbBisFlag(m_includeCtbBis);
     mysql->setControlAlines(m_controlAlines);
     
     dbr->setGeometryVersion(m_layout);
     dbr->setManager(m_manager);
     sc = dbr->ProcessDB();
     if (sc != StatusCode::SUCCESS)
     {
         log << MSG::ERROR<<" FAILURE in DB access; Muon node will not be built"<<endreq;
         return;
     }
     //release memory
     delete dbr;
     dbr = 0;
 
     umem = GeoPerfUtils::getMem();
     ucpu = int(GeoPerfUtils::getCpu()/100.);
     geoModelStats <<"At MuonDetectorFactory::DB read             \t SZ= " <<umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = "<<umem-mem<<" \t Delta T ="<<ucpu - cpu << std::endl;
     mem = umem;
     cpu = ucpu;
     
 
 
     
     // now store detector-generic-descriptors into the manager
     RPC* r = (RPC*)mysql->GetATechnology("RPC0");
     GenericRPCCache rpcCache;
     rpcCache.stripSeparation = r->stripSeparation;
     rpcCache.stripPanelThickness = r->stripPanelThickness;
     rpcCache.rpcLayerThickness = r->rpcLayerThickness;
     rpcCache.centralSupPanelThickness = r->centralSupPanelThickness;
     rpcCache.GasGapThickness = r->GasGapThickness;
     rpcCache.frontendBoardWidth = r->frontendBoardWidth;
     m_manager->setGenericRpcDescriptor(rpcCache);
 
     MDT* m = (MDT*)mysql->GetATechnology("MDT0");
     GenericMDTCache mdtCache;
     mdtCache.innerRadius = m->innerRadius;
     m_manager->setGenericMdtDescriptor(mdtCache);
 
     TGC* t = (TGC*)mysql->GetATechnology("TGC0");
     GenericTGCCache tgcCache;
     tgcCache.frame_h = t->frame_h;
     tgcCache.frame_ab = t->frame_ab;
     tgcCache.nlayers = t->nlayers;
 //     std::cout << " TGC SIZE CHECK: nlayers = " << t->nlayers 
 //               << " materials.size() = " << (t->materials).size() << std::endl;
 // no need for the following info in the Generic TGC cache  
 //     for (unsigned int i = 0; i < (t->materials).size(); i++) 
 //     {
 //      //tgcCache.materials[i] = t->materials[i];
 //      (tgcCache.materials).push_back(t->materials[i]);
 //      //tgcCache.positions[i] = t->positions[i];
 //      (tgcCache.positions).push_back(t->positions[i]);
 //      //tgcCache.tck[i] = t->tck[i];
 //      (tgcCache.tck).push_back(t->tck[i]);
 //     }
     m_manager->setGenericTgcDescriptor(tgcCache);
 
 //    CSC* c = (CSC*)mysql->GetATechnology("CSC0");
     GenericCSCCache cscCache;
     cscCache.dummy1 = 0;
     cscCache.dummy2 = 0;
     m_manager->setGenericCscDescriptor(cscCache);
 
     const StoredMaterialManager*  theMaterialManager;
     if ( StatusCode::SUCCESS != m_pDetStore->retrieve( theMaterialManager, "MATERIALS" ) )  
     {
         return;
     }
     else
         log<< MSG::INFO
            <<" theMaterialManager retrieven successfully from the DetStore"
            <<endreq;
   
   
     DetectorElement::setMaterialManager(*theMaterialManager);  
   
     const GeoMaterial* m4 = theMaterialManager->getMaterial( "std::Air" );
     GeoLogVol*  l4;
     if (m_layout != "CTB2004")
     {
         GeoPcon* c4 = new GeoPcon( 0, 360*deg );
         //--- --- --- CREATE ENVELOPE --- --- ---
         // First try to get data from the GeomDB
         const IRDBRecordset* muonSysRec = m_pRDBAccess->getRecordset("MuonSystem",OracleTag,OracleNode);
         // -- Next two lines allow to use MuonSystem-00 by default instead of hardwired numbers
         //    even for geometry tags where MuonSystem was not collected 
         if(muonSysRec->size()==0)
         {
             muonSysRec = m_pRDBAccess->getRecordset("MuonSystem","MuonSystem-00");
             log<< MSG::INFO
                <<"MuonSystem description from default node in GeomDB, i.e. MuonSystem-00"<<endreq;
         }
         else log<< MSG::INFO
                 <<"MuonSystem description from OracleTag=<"<<OracleTag<<"> and node=<"<< OracleNode<<">"<<endreq;
         //
 
         // --- Envelope from DB ....
         if(muonSysRec->size()!=0)
         {
             // Data retrieved
             muonsysIndMap _map;
             muonsysIndMap::const_iterator iter;
             const IRDBRecord* currentRecord;
             
             // First fill the contents of muonsysIndMap
             for (unsigned int ind=0; ind<muonSysRec->size(); ind++)
             {
                 int key = (*muonSysRec)[ind]->getInt("PLANE_ID");
                 _map[key] = ind;
             }
             
             // Create the polycone
             for(unsigned int ind=0; ind<_map.size(); ind++)
             {
                 iter = _map.find(ind);
                 
                 if(iter==_map.end())
                     throw std::runtime_error("Error in MuonDetectorFactory, missing plane in MuonSystem");
                 else
                 {
                     currentRecord = (*muonSysRec)[(*iter).second];
                     c4->addPlane(currentRecord->getDouble("ZPLANE"),
                                  currentRecord->getDouble("RMIN"),
                                  currentRecord->getDouble("RMAX"));
                 }
             }
         }// ... end if  Envelope from DB ---
         else
         {
             // Muon System node is not present, go for handcoded version
             log<< MSG::INFO
                <<"MuonSystem description not available in GeomDB - using hard-wired description"<<endreq;
             
             double ir   = m_muon->barrelInnerRadius;
             double pir  = m_muon->innerRadius;
             double orad = m_muon->outerRadius;
             double l    = m_muon->length;
             double eff  = m_muon->endcapFrontFace;
             
             double extraR = m_muon->extraR;
             double extraZ = m_muon->extraZ;
             
             
             c4->addPlane(     -l, pir, extraR);
             c4->addPlane(-extraZ, pir, extraR);
             c4->addPlane(-extraZ, pir, orad);
             
             c4->addPlane(-eff, pir, orad);
             c4->addPlane(-eff,  ir, orad);
             c4->addPlane(+eff,  ir, orad);
             c4->addPlane(+eff, pir, orad);
             
             c4->addPlane(extraZ, pir, orad);
             c4->addPlane(extraZ, pir, extraR);
             c4->addPlane(     l, pir, extraR);
         }
         l4 = new GeoLogVol( "MuonSys", c4, m4 );
     }
     else 
     {
         double xhlen,yhlen,zhlen, xstart;
         if (mysql->getLayoutName() == "a.05" || mysql->getLayoutName() == "b.01") 
         {
             xhlen=22702.0*mm-1.*mm;
             yhlen=4100.0*mm-1.*mm;
             zhlen=2800.0*mm-1.*mm;
             xstart = 12198.0*mm;
         }
         else
         {
             xhlen=22000.*mm-1.*mm;
             yhlen=zhlen=6000.*mm-1.*mm;
             xstart = 12175*mm;
         }
         const GeoShape* c4 = new GeoBox(xhlen,yhlen,zhlen);
         c4 = & ( (*c4)<<HepTranslateX3D( xhlen+xstart)  );
         l4 = new GeoLogVol( "MuonSys", c4, m4 );
         log<< MSG::INFO<<" Here is the tree top volume for the CTB"<<endreq;
     }
     GeoPhysVol* p4 = new GeoPhysVol(l4);
   
     // Cannot (yet) cope with this:
     // G4UserLimits *ul=new G4UserLimits;
     // ul->SetMaxAllowedStep(5*cm);
     // lv->GetLogicalVolume()->SetUserLimits(ul);
   
     m_manager->addTreeTop(p4); // This is the top!
     log << MSG::INFO<<" TreeTop added to the Manager"<<endreq;
     log << MSG::INFO<<" Muon Layout "<< m_layout << endreq;
 
     
     std::vector<std::string> slist;
     if (m_selectedStations.size()<=0) slist.push_back("*");
     else slist = m_selectedStations;
     
 
     // create the fullphysvol map to allow cloning and save memory
     FPVMAP* savemem = FPVMAP::GetPointer();
   
   
     int nstat_ss = 0;
     int ntpos_ss = 0;
     int npos_ss = 0;
     int nAssemblies = 0;
     if (m_enableFineClashFixing >0)
         log<<MSG::INFO
            <<"Fine Clash Fixing enabled:  (should be ON/OFF for Simulation/Reconstruction)"<<endreq;
     else
         log<<MSG::INFO
            <<"Fine Clash Fixing disabled: (should be ON/OFF for Simulation/Reconstruction)"<<endreq;
 
     StationSelector sel(slist);
     StationSelector::StationIterator it;
     //  log<<MSG::DEBUG<<" Size of the station list is ???"<<endreq;
     for ( it = sel.begin(); it != sel.end(); it++ )
     {
         Station *station = (*it).second;
         std::string stname(station->GetName(), 0, 3);
         if (m_selectedStations.size()<=0) 
             log<<MSG::VERBOSE<<"Processing Stations named <"<<station->GetName()<<"> "
                <<nstat_ss<<" built until now"<<endreq;
 
         if ((skip_chambers) && (stname.substr(0,1)!="X")) continue;
 
         bool isAssembly = false;
         if (station->GetNrOfCutouts() > 0 && stname.substr(0,1) != "T") isAssembly = true;
         MuonChamber l(station);  // here is where we start to create a MuonChamber with all readoutelements
         l.setFineClashFixingFlag(m_enableFineClashFixing);
 
         PositionIterator pit;
         AlignPosIterator apit;
         AlignPos ap;
         npos_ss = 0;
         for ( pit = station->begin(); pit != station->end(); pit++ )
         {
             int zi = (*pit).second.zindex;
             int fi = (*pit).second.phiindex;
             int sign = 1;
             if(zi) sign = zi/abs(zi);
 
             // if there's a selection of eta location, check if this chamber is selected
             if (m_selectedStEta.size() >0) 
             {
                 bool selectedEta = false;
                 for (std::vector<int>::iterator i=m_selectedStEta.begin(); i<m_selectedStEta.end(); i++)
                 {
                     if (zi == *i)
                     {
                         selectedEta = true;
                         break;
                     }
                 }
                 if (!selectedEta) continue;
             }
             // if there's a selection of phi location, check if this chamber is selected
             if (m_selectedStPhi.size() >0) 
             {
                 bool selectedPhi = false;
                 for (std::vector<int>::iterator i=m_selectedStPhi.begin(); i<m_selectedStPhi.end(); i++)
                 {
                     if ((fi+1) == *i)
                     {
                         selectedPhi = true;
                         break;
                     }
                 }
                 if (!selectedPhi) continue;
             }
 
             // total number of stations positioned in the layout
             ntpos_ss++;
             // total number of locations for this chamber 
             npos_ss++;
             
             if ((m_selectedStPhi.size() + m_selectedStEta.size()) >0)
                 log<<MSG::INFO<<"Build selected Station <"<<station->GetName()<<"> at Jzz = "<<zi<<" Jff = "<<fi+1<<" ******* "
                <<nstat_ss<<" stat.types built until now"<<endreq;
             
 
             // here define GeoNameTag 
             GeoNameTag   *nm = new GeoNameTag( station->GetName() + "_station" );
 
             // here build the physical volume (tree) associated to the chamber 
             bool is_mirrored =  ((*pit).second).isMirrored;
             int mirsign = 0;
             if ( zi<0 && !is_mirrored ) mirsign = 1;
             if (stname=="CSL") isAssembly = true; 
                 //CSL because coffin shape of the station mother volume
             GeoVPhysVol *pv = l.build(m_manager, zi, fi, is_mirrored, isAssembly);
             if (isAssembly) nAssemblies ++;
 
             // here define GeoIdentifierTag 
             if (useAssemblies || isAssembly) 
             {
                 int sideC = 0;
                 if ( zi<0 ) sideC = 1;
                 int geoid = (sideC*10000 + mirsign*1000 + abs(zi)*100 + fi+1)*100000;
                 log<<MSG::DEBUG<<"Adding Station with nameTag=<"<<station->GetName() + "_station"
                    <<"> and geoId "<<geoid<<endreq;
                 p4->add(new GeoIdentifierTag (geoid));
             }
             else 
             {
                 int geoid = (mirsign*1000 + abs(zi)*100 + fi+1)*sign;
                 p4->add(new GeoIdentifierTag (geoid));
                 log<<MSG::DEBUG<<"Adding Station with nameTag=<"<<station->GetName() + "_station"
                    <<"> and geoId "<<geoid<<" for zi/fi = "<<zi<<"/"<<fi<<endreq;
             }            
             
             // here define the GeoAlignableTransform associated to the chamber
             HepTransform3D DummyAline = HepTransform3D::Identity;
             // nominal transform first 
             GeoAlignableTransform *xf = new GeoAlignableTransform( station->getNominalTransform( (*pit).second) );             
             // find correct alignment information for this position
             xf->setDelta(DummyAline); // just in case we don't find one
             apit = station->FindAlignPos(zi,fi);
             HepTransform3D Delta = HepTransform3D::Identity;
 //             log<<MSG::VERBOSE << "From the Factory:: Nominal transformation for " << stname << ":"
 //                << endreq <<
 //                 (xf->getTransform())[0][0] << " " <<
 //                 (xf->getTransform())[0][1] << " " <<
 //                 (xf->getTransform())[0][2] << " " <<
 //                 (xf->getTransform())[0][3] << " " << endreq <<
 //                 (xf->getTransform())[1][0] << " " <<
 //                 (xf->getTransform())[1][1] << " " <<
 //                 (xf->getTransform())[1][2] << " " <<
 //                 (xf->getTransform())[1][3] << " " << endreq <<
 //                 (xf->getTransform())[2][0] << " " <<
 //                 (xf->getTransform())[2][1] << " " <<
 //                 (xf->getTransform())[2][2] << " " <<
 //                 (xf->getTransform())[2][3] << " " << endreq;
             if (apit != station->aend())
             {   //just consistency checks here 
                 //std::cout<<"There's a delta transform to be applied"<<std::endl;
                 ap = apit->second;
                 //                ap.rots = 0.001356;
                 //                ap.rotz =-0.001113;
                 //                ap.rott = 0.001067;
                 if (ap.phiindex != fi || ap.zindex != zi)
                 {
                     log<<MSG::ERROR<<"Inconsistent AlignedPosition found in the static Geometry DB: aligPos.fi, zi = "<< ap.phiindex<<", "<<ap.zindex
                        <<" for station "<<station->GetName()<<" at fi/zi = "<<fi<<"/"<<zi
                        <<" AlignPos indices fi/zi "<<fi<<"/"<<zi<<endreq;
                 }
                 else
                 {
                     //old-style: update the transform with a Delta computed in the Station class
                     // Delta = station->getDeltaTransform( ap, (*pit).second );
 //                     log<<MSG::VERBOSE << "From the Factory:: Delta(tsz) transformation for " << stname << ":"
 //                        << endreq <<
 //                         (Delta)[0][0] << " " <<
 //                         (Delta)[0][1] << " " <<
 //                         (Delta)[0][2] << " " <<
 //                         (Delta)[0][3] << " " << endreq <<
 //                         (Delta)[1][0] << " " <<
 //                         (Delta)[1][1] << " " <<
 //                         (Delta)[1][2] << " " <<
 //                         (Delta)[1][3] << " " << endreq <<
 //                         (Delta)[2][0] << " " <<
 //                         (Delta)[2][1] << " " <<
 //                         (Delta)[2][2] << " " <<
 //                         (Delta)[2][3] << " " << endreq;
                     // xf->setDelta( Delta );
                 }
             }
             else {
                 log<<MSG::DEBUG <<"No A-lines -> AlignedPositions for this station in the static Geometry DB"<<endreq;
                 ap.tras=ap.traz=ap.trat=ap.rots=ap.rotz=ap.rott=0.;
             }
 //             log<<MSG::VERBOSE << "From the Factory:: Total transformation for " << stname << ":"
 //                << endreq <<
 //                 (xf->getTransform())[0][0] << " " <<
 //                 (xf->getTransform())[0][1] << " " <<
 //                 (xf->getTransform())[0][2] << " " <<
 //                 (xf->getTransform())[0][3] << " " << endreq <<
 //                 (xf->getTransform())[1][0] << " " <<
 //                 (xf->getTransform())[1][1] << " " <<
 //                 (xf->getTransform())[1][2] << " " <<
 //                 (xf->getTransform())[1][3] << " " << endreq <<
 //                 (xf->getTransform())[2][0] << " " <<
 //                 (xf->getTransform())[2][1] << " " <<
 //                 (xf->getTransform())[2][2] << " " <<
 //                 (xf->getTransform())[2][3] << " " << endreq;
             // get the MuonStation from the manager; store the relevant transforms;
             // let the MuonStation compute the Delta of the GeoAlignableTransform (new style)
             MuonStation* mst = m_manager->getMuonStation (station->GetName(), zi, fi+1);
             if (mst != NULL) {
                 mst->setTransform(xf);
                 HepTransform3D tsz_to_szt = HepTransform3D(HepPoint3D(1.,0.,0.),HepPoint3D(0.,1.,0.),
                                                            HepPoint3D(0.,0.,1.),HepPoint3D(0.,0.,1.),
                                                            HepPoint3D(1.,0.,0.),HepPoint3D(0.,1.,0.));
                 mst->setNativeToAmdbLRS( tsz_to_szt * station->native_to_tsz_frame( (*pit).second ) );
                 mst->setNominalAmdbLRSToGlobal( station->tsz_to_global_frame( (*pit).second ) * tsz_to_szt.inverse() );
 //                 log<<MSG::VERBOSE << "From the Factory:: Before setting delta to the MuonStation " << stname << ":"
 //                    << endreq <<
 //                     (xf->getTransform())[0][0] << " " <<
 //                     (xf->getTransform())[0][1] << " " <<
 //                     (xf->getTransform())[0][2] << " " <<
 //                     (xf->getTransform())[0][3] << " " << endreq <<
 //                     (xf->getTransform())[1][0] << " " <<
 //                     (xf->getTransform())[1][1] << " " <<
 //                     (xf->getTransform())[1][2] << " " <<
 //                     (xf->getTransform())[1][3] << " " << endreq <<
 //                     (xf->getTransform())[2][0] << " " <<
 //                     (xf->getTransform())[2][1] << " " <<
 //                     (xf->getTransform())[2][2] << " " <<
 //                     (xf->getTransform())[2][3] << " " << endreq;
              // HepTransform3D Delta_amdb_frame = tsz_to_szt*station->getDeltaTransform_tszFrame(ap)*tsz_to_szt.inverse();
              // mst->setDeltaAmdbLRS(  Delta_amdb_frame );
 //                 log<<MSG::VERBOSE << "From the Factory:: Delta(amdb) transformation for " << stname << ":"
 //                    << endreq <<
 //                     (Delta_amdb_frame)[0][0] << " " <<
 //                     (Delta_amdb_frame)[0][1] << " " <<
 //                     (Delta_amdb_frame)[0][2] << " " <<
 //                     (Delta_amdb_frame)[0][3] << " " << endreq <<
 //                     (Delta_amdb_frame)[1][0] << " " <<
 //                     (Delta_amdb_frame)[1][1] << " " <<
 //                     (Delta_amdb_frame)[1][2] << " " <<
 //                     (Delta_amdb_frame)[1][3] << " " << endreq <<
 //                     (Delta_amdb_frame)[2][0] << " " <<
 //                     (Delta_amdb_frame)[2][1] << " " <<
 //                     (Delta_amdb_frame)[2][2] << " " <<
 //                     (Delta_amdb_frame)[2][3] << " " << endreq;
 //                 //now get and check the full transform
 //                 log<<MSG::VERBOSE << "From MuonStation:: Total transformation for " << stname << ":"
 //                    << endreq <<
 //                     (xf->getTransform())[0][0] << " " <<
 //                     (xf->getTransform())[0][1] << " " <<
 //                     (xf->getTransform())[0][2] << " " <<
 //                     (xf->getTransform())[0][3] << " " << endreq <<
 //                     (xf->getTransform())[1][0] << " " <<
 //                     (xf->getTransform())[1][1] << " " <<
 //                     (xf->getTransform())[1][2] << " " <<
 //                     (xf->getTransform())[1][3] << " " << endreq <<
 //                     (xf->getTransform())[2][0] << " " <<
 //                     (xf->getTransform())[2][1] << " " <<
 //                     (xf->getTransform())[2][2] << " " <<
 //                     (xf->getTransform())[2][3] << " " << endreq;
                 //now get and check the full transform after updating the delta directly with a-line
                 //std::cout<<setiosflags(std::ios::fixed) << std::setprecision(6) << std::setw(12);
                 //std::cout<<"A-lines from DB to MuonStation: "<<ap.tras<<" "<<ap.traz<<" "<<ap.trat<<" "<<ap.rots<<" "<<ap.rotz<<" "<<ap.rott<<std::endl;
                 mst->setDelta_fromAline( ap.tras, ap.traz, ap.trat, ap.rots, ap.rotz, ap.rott );
 //                 log<<MSG::VERBOSE << "From MuonStation (A line):: Total transformation for " << stname << ":"
 //                    << endreq <<
 //                     (xf->getTransform())[0][0] << " " <<
 //                     (xf->getTransform())[0][1] << " " <<
 //                     (xf->getTransform())[0][2] << " " <<
 //                     (xf->getTransform())[0][3] << " " << endreq <<
 //                     (xf->getTransform())[1][0] << " " <<
 //                     (xf->getTransform())[1][1] << " " <<
 //                     (xf->getTransform())[1][2] << " " <<
 //                     (xf->getTransform())[1][3] << " " << endreq <<
 //                     (xf->getTransform())[2][0] << " " <<
 //                     (xf->getTransform())[2][1] << " " <<
 //                     (xf->getTransform())[2][2] << " " <<
 //                     (xf->getTransform())[2][3] << " " << endreq;
             }
             else log<<MSG::ERROR<<"Cannot record the alignable transform in the MuonStation; MuonStation not found for stName= "
                     <<station->GetName()<<" zi/fi "<<zi<<"/"<<fi+1
                     <<endreq;
 
             // add tag, transform and physicalvolume associated to the chamber to the mother-volume
             p4->add(nm);
             p4->add(xf);
             p4->add(pv);
             //m_manager->addStation(xf,nm); //ss 19-02-2007 not needed anymore 
         }//end loop on positions 
         //number of stations realised in the layout 
         if (npos_ss >0) nstat_ss ++;
     }
     
 
     log<<MSG::INFO<<" **************** MuonDetectorFactory001 ****************************"<<endreq
        <<" *** The Muon Chamber Geometry Tree is built with "<<endreq
        <<" *** "<<p4->getNChildVols()<<" child volumes "<<endreq
        <<" *** "<<savemem->NDetectors()<<" independent elements and "<<endreq
        <<" *** "<<savemem->NDetectorsReused()<<" elements cloned or shared "<<endreq
        <<" *** "<<nstat_ss<<" kinds of stations"<<endreq
        <<" *** "<<ntpos_ss<<" stations with alignable transforms"<<endreq
        <<" *** "<<nAssemblies<<" stations are described as Assemblies"<<endreq
        <<" *** "<<m_manager->nMuonStation()<<" MuonStations "<<endreq
        <<" *** \t "<<m_manager->nMdtRE()<<" MDT Readout Elements \t "
        <<m_manager->nMdtDE()<<" MDT Detector Elements "<<endreq
        <<" *** \t "<<m_manager->nCscRE()<<" CSC Readout Elements \t "
        <<m_manager->nCscDE()<<" CSC Detector Elements "<<endreq
        <<" *** \t "<<m_manager->nRpcRE()<<" RPC Readout Elements \t "
        <<m_manager->nRpcDE()<<" RPC Detector Elements "<<endreq
        <<" *** \t "<<m_manager->nTgcRE()<<" TGC Readout Elements \t "
        <<m_manager->nTgcDE()<<" TGC Detector Elements "<<endreq
        <<" ********************************************************************"<<endreq;
 
     umem = GeoPerfUtils::getMem();
     ucpu = int(GeoPerfUtils::getCpu()/100.);
     geoModelStats <<"At MuonDetectorFactory::active geo done     \t SZ= " <<umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = "<<umem-mem<<" \t Delta T ="<<ucpu - cpu << std::endl;
     mem = umem;
     cpu = ucpu;
     
 
 
     
     // delete the fullphysvol map
     delete savemem;
     savemem = NULL;
 
     // delete the station and technology map
     delete mysql;
     mysql = NULL;
 
 
     umem = GeoPerfUtils::getMem();
     ucpu = int(GeoPerfUtils::getCpu()/100.);
     geoModelStats <<"At MuonDetectorFactory::released access.mem \t SZ= " <<umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = "<<umem-mem<<" \t Delta T ="<<ucpu - cpu << std::endl;
     mem = umem;
     cpu = ucpu;
 
 
 
     
     GeoNameTag *ntg = new GeoNameTag( "Muon" );
     world->add(ntg);
     world->add(p4);       
     
     //if (  (!includeInertMaterials) || m_layout == "CTB2004" ) return;
     if (  (includeInertMaterials) && (m_layout != "CTB2004") ) 
     {
         
     //------------------------------------------------------------------------------------------
     //  Build Toroids (Barrel/Endcap), Feet and Rails 
     //------------------------------------------------------------------------------------------  
     log << MSG::INFO <<  " *** Going to build Muon Toroids/Feet/Supports/Rails **************** "
         << endreq;
     
     if (buildBarrelToroid)
     {
       BarrelToroidBuilderV* m_barreltoroidBuilder;
       m_barreltoroidBuilder = new BarrelToroidBuilderRDB( m_pDetStore, m_pRDBAccess, 
                                                           OracleTag, OracleNode);
       // Barrel Toroid 
       m_barreltoroidBuilder->buildBTVacuumVessel(p4);
       m_barreltoroidBuilder->buildBTColdMass(p4);
       m_barreltoroidBuilder->buildBTVoussoirs(p4);
       m_barreltoroidBuilder->buildBTStruts(p4);
       m_barreltoroidBuilder->buildBTCryoring(p4);
       // Rails
       m_barreltoroidBuilder->buildRails(p4);
       // release memory
       delete  m_barreltoroidBuilder;
       m_barreltoroidBuilder = 0;
     }
     if (buildEndcapToroid)
     {
       EndCapToroidBuilderV* m_endcaptoroidBuilder;
       m_endcaptoroidBuilder = new EndCapToroidBuilderRDB( m_pDetStore, m_pRDBAccess,
                                                           OracleTag, OracleNode);
       // Endcap Toroid
       m_endcaptoroidBuilder->buildECTVacuumVessel(p4);
       m_endcaptoroidBuilder->buildECTConductorBox(p4);
       m_endcaptoroidBuilder->buildECTKeystoneBox(p4);
       m_endcaptoroidBuilder->buildECTServiceTower(p4);
       //release memory 
       delete  m_endcaptoroidBuilder;
       m_endcaptoroidBuilder = 0;
     }
     if (buildFeet)
     {
       FeetToroidBuilderV*   m_feettoroidBuilder;
       m_feettoroidBuilder = new FeetToroidBuilderRDB( m_pDetStore, m_pRDBAccess,
                                                       OracleTag, OracleNode);
       // Feet
       m_feettoroidBuilder->buildStandardFeet(p4);
       m_feettoroidBuilder->buildExtremityFeet(p4);
       m_feettoroidBuilder->buildFeetGirders(p4);
       m_feettoroidBuilder->buildFeetRailSupports(p4);
       m_feettoroidBuilder->buildFeetVoussoirs(p4);
       //release memory
       delete  m_feettoroidBuilder;
       m_feettoroidBuilder   = 0;
     }
 
     if (buildDiskShielding || buildToroidShielding || buildForwardShielding)
     {
         ShieldBuilderV* m_shieldBuilder;
         m_shieldBuilder = new ShieldBuilderRDB( m_pDetStore, m_pRDBAccess, OracleTag, OracleNode );
         // JD, JTT, and JF Shielding 
         if (buildDiskShielding)    m_shieldBuilder->buildDiskShielding(p4); // conflicts with CSCs in layout P03
         if (buildToroidShielding)  m_shieldBuilder->buildToroidShielding(p4);
         if (buildForwardShielding) m_shieldBuilder->buildForwardShielding(p4);
 
         //release memory 
         delete m_shieldBuilder;
         m_shieldBuilder = 0;
     }
 
     if (buildCaloSaddle)
     {
         CalorimeterSaddleBuilder * caloSaddleBuilder = new CalorimeterSaddleBuilder( m_pDetStore,
                                                                                      m_pRDBAccess,
                                                                                      OracleTag,
                                                                                      OracleNode );
         caloSaddleBuilder->build(p4);
         delete caloSaddleBuilder;
         caloSaddleBuilder = 0;
     }
     
 
     log << MSG::INFO
         << " *** The Muon Toroids/Feet/Supports/Rails/Shielding are built ****** "<< endreq;
     }
     log << MSG::INFO
         << " *** Inert Material built according to DB switches and config. ****** "<< endreq;
     log << MSG::INFO
         << " *** The Muon Geometry Tree has " << p4->getNChildVols() << " child vol.s in total ********"<< endreq
         << " ********************************************************************\n"<< endreq;
   
     umem = GeoPerfUtils::getMem();
     ucpu = int(GeoPerfUtils::getCpu()/100.);
     geoModelStats <<"At MuonDetectorFactory::inert  geo done     \t SZ= " <<umem << " Kb \t Time = " << ucpu << " seconds  ---- \t DeltaM = "<<umem-mem<<" \t Delta T ="<<ucpu - cpu << std::endl;
     mem = umem;
     cpu = ucpu;
     
     geoModelStats.close();
 
 }
 
 } // namespace MuonGM
 

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.