Skip to content
Snippets Groups Projects
Commit 7a407059 authored by Marilena Bandieramonte's avatar Marilena Bandieramonte
Browse files

Merge branch 'master-EMECVariants' into 'master' 

Master new EMEC variants

See merge request !2
parents 05352229 ebec2e4d
No related branches found
No related tags found
1 merge request!2Master new EMEC variants
Pipeline #1674824 passed with warnings
Stage: deps-geomodelcore
Stage: deps-CLHEP
Stage: deps-xerces-c
Stage: deps-Geant4
Stage: build
Show whitespace changes
Inline Side-by-side
GeoModel2G4/GeoModel2G4/Geo2G4SolidFactory.h
+ 2
− 0
View file @ 7a407059
......@@ -12,6 +12,7 @@
class G4VSolid;
class GeoShape;
class GeoUnidentifiedShape;
class Geo2G4SolidFactory
{
......@@ -30,6 +31,7 @@ public:
//StoreGateSvc_t& detStore() const;
private:
G4VSolid* createLArWheelSolid(const std::string& name, const LArWheelSolidDef_t & lwsdef) const;
G4VSolid* createLArWheelSliceSolid(const GeoUnidentifiedShape* ) const;
static const LArWheelSolid_typemap s_lwsTypes;
......
GeoModel2G4/GeoModel2G4/LArWheelSliceSolid.h
+ 1
− 1
View file @ 7a407059
......@@ -49,7 +49,7 @@ class LArWheelSliceSolid : public G4VSolid
G4int zside = 1,
const LArWheelCalculator *calc = 0
);
LArWheelSliceSolid(const G4String& name, const LArWheelCalculator *calc);
LArWheelSliceSolid(const G4String& name);
virtual ~LArWheelSliceSolid(){}
// Mandatory for custom solid Geant4 functions
......
GeoModel2G4/src/G4ShiftedCone.icc 0 → 100644
+ 338
− 0
View file @ 7a407059
/*
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
// --------------------------------------------------------------------
// GEANT 4 inline definitions file
//
// G4ShiftedCone.icc
//
// Implementation of inline methods of G4ShiftedCone
// --------------------------------------------------------------------
inline
G4double G4ShiftedCone::GetInnerRadiusMinusZ() const
{
return fRmin1 ;
}
inline
G4double G4ShiftedCone::GetOuterRadiusMinusZ() const
{
return fRmax1 ;
}
inline
G4double G4ShiftedCone::GetInnerRadiusPlusZ() const
{
return fRmin2 ;
}
inline
G4double G4ShiftedCone::GetOuterRadiusPlusZ() const
{
return fRmax2 ;
}
inline
G4double G4ShiftedCone::GetZHalfLength() const
{
return fDz ;
}
inline
G4double G4ShiftedCone::GetZ1() const
{
return fZshift - fDz ;
}
inline
G4double G4ShiftedCone::GetZ2() const
{
return fZshift + fDz ;
}
inline
G4double G4ShiftedCone::GetStartPhiAngle() const
{
return 0.; // fSPhi ;
}
inline
G4double G4ShiftedCone::GetDeltaPhiAngle() const
{
return CLHEP::twopi; //fDPhi;
}
inline
G4double G4ShiftedCone::GetSinStartPhi() const
{
return 0.; //sinSPhi;
}
inline
G4double G4ShiftedCone::GetCosStartPhi() const
{
return 1.;// cosSPhi;
}
inline
G4double G4ShiftedCone::GetSinEndPhi() const
{
return 0.;// sinEPhi;
}
inline
G4double G4ShiftedCone::GetCosEndPhi() const
{
return 1.;//cosEPhi;
}
inline
void G4ShiftedCone::Initialize()
{
fCubicVolume = 0.;
fSurfaceArea = 0.;
fRebuildPolyhedron = true;
}
/*
inline
void G4ShiftedCone::InitializeTrigonometry()
{
G4double hDPhi = 0.5*fDPhi; // half delta phi
G4double cPhi = fSPhi + hDPhi;
G4double ePhi = fSPhi + fDPhi;
sinCPhi = std::sin(cPhi);
cosCPhi = std::cos(cPhi);
cosHDPhiIT = std::cos(hDPhi - 0.5*kAngTolerance); // inner/outer tol half dphi
cosHDPhiOT = std::cos(hDPhi + 0.5*kAngTolerance);
sinSPhi = std::sin(fSPhi);
cosSPhi = std::cos(fSPhi);
sinEPhi = std::sin(ePhi);
cosEPhi = std::cos(ePhi);
}
inline void G4ShiftedCone::CheckSPhiAngle(G4double sPhi)
{
// Ensure fSphi in 0-2PI or -2PI-0 range if shape crosses 0
if ( sPhi < 0 )
{
fSPhi = CLHEP::twopi - std::fmod(std::fabs(sPhi),CLHEP::twopi);
}
else
{
fSPhi = std::fmod(sPhi,CLHEP::twopi) ;
}
if ( fSPhi+fDPhi > CLHEP::twopi )
{
fSPhi -= CLHEP::twopi ;
}
}
inline void G4ShiftedCone::CheckDPhiAngle(G4double dPhi)
{
fPhiFullCone = true;
if ( dPhi >= CLHEP::twopi-kAngTolerance*0.5 )
{
fDPhi=CLHEP::twopi;
fSPhi=0;
}
else
{
fPhiFullCone = false;
if ( dPhi > 0 )
{
fDPhi = dPhi;
}
else
{
std::ostringstream message;
message << "Invalid dphi." << G4endl
<< "Negative or zero delta-Phi (" << dPhi << ") in solid: "
<< GetName();
G4Exception("G4ShiftedCone::CheckDPhiAngle()", "GeomSolids0002",
FatalException, message);
}
}
}
inline void G4ShiftedCone::CheckPhiAngles(G4double sPhi, G4double dPhi)
{
CheckDPhiAngle(dPhi);
if ( (fDPhi<CLHEP::twopi) && (sPhi) ) { CheckSPhiAngle(sPhi); }
InitializeTrigonometry();
}
*/
inline
void G4ShiftedCone::SetInnerRadiusMinusZ( G4double Rmin1 )
{
fRmin1= Rmin1 ;
Initialize();
}
inline
void G4ShiftedCone::SetOuterRadiusMinusZ( G4double Rmax1 )
{
fRmax1= Rmax1 ;
Initialize();
}
inline
void G4ShiftedCone::SetInnerRadiusPlusZ ( G4double Rmin2 )
{
fRmin2= Rmin2 ;
Initialize();
}
inline
void G4ShiftedCone::SetOuterRadiusPlusZ ( G4double Rmax2 )
{
fRmax2= Rmax2 ;
Initialize();
}
/*inline
void G4ShiftedCone::SetZHalfLength ( G4double newDz )
{
fDz= newDz ;
Initialize();
}*/
/*
inline
void G4ShiftedCone::SetStartPhiAngle ( G4double newSPhi, G4bool compute )
{
// Flag 'compute' can be used to explicitely avoid recomputation of
// trigonometry in case SetDeltaPhiAngle() is invoked afterwards
CheckSPhiAngle(newSPhi);
fPhiFullCone = false;
if (compute) { InitializeTrigonometry(); }
Initialize();
}
void G4ShiftedCone::SetDeltaPhiAngle ( G4double newDPhi )
{
CheckPhiAngles(fSPhi, newDPhi);
Initialize();
}
*/
// Old access methods ...
inline
G4double G4ShiftedCone::GetRmin1() const
{
return GetInnerRadiusMinusZ();
}
inline
G4double G4ShiftedCone::GetRmax1() const
{
return GetOuterRadiusMinusZ();
}
inline
G4double G4ShiftedCone::GetRmin2() const
{
return GetInnerRadiusPlusZ();
}
inline
G4double G4ShiftedCone::GetRmax2() const
{
return GetOuterRadiusPlusZ();
}
/*
inline
G4double G4ShiftedCone::GetDz() const
{
return GetZHalfLength();
}
inline
G4double G4ShiftedCone::GetSPhi() const
{
return GetStartPhiAngle();
}
inline
G4double G4ShiftedCone::GetDPhi() const
{
return GetDeltaPhiAngle();
}
*/
inline
G4double G4ShiftedCone::GetCubicVolume()
{
if(fCubicVolume != 0.) {;}
else
{
G4double Rmean, rMean, deltaR, deltar;
Rmean = 0.5*(fRmax1+fRmax2);
deltaR = fRmax1-fRmax2;
rMean = 0.5*(fRmin1+fRmin2);
deltar = fRmin1-fRmin2;
fCubicVolume = GetDeltaPhiAngle()*fDz*(Rmean*Rmean-rMean*rMean
+(deltaR*deltaR-deltar*deltar)/12);
}
return fCubicVolume;
}
inline
G4double G4ShiftedCone::GetSurfaceArea()
{
if(fSurfaceArea != 0.) {;}
else
{
G4double mmin, mmax, dmin, dmax;
mmin= (fRmin1+fRmin2)*0.5;
mmax= (fRmax1+fRmax2)*0.5;
dmin= (fRmin2-fRmin1);
dmax= (fRmax2-fRmax1);
fSurfaceArea = GetDeltaPhiAngle()*( mmin * std::sqrt(dmin*dmin+4*fDz*fDz)
+ mmax * std::sqrt(dmax*dmax+4*fDz*fDz)
+ 0.5*(fRmax1*fRmax1-fRmin1*fRmin1
+fRmax2*fRmax2-fRmin2*fRmin2 ));
/* if(!fPhiFullCone)
{
fSurfaceArea = fSurfaceArea+4*fDz*(mmax-mmin);
}*/
}
return fSurfaceArea;
}
GeoModel2G4/src/Geo2G4SolidFactory.cxx
+ 109
− 105
View file @ 7a407059
......@@ -4,6 +4,7 @@
#include "GeoModel2G4/Geo2G4SolidFactory.h"
#include "GeoModel2G4/LArWheelSolid.h"
#include "GeoModel2G4/LArWheelSliceSolid.h"
#include "GeoModel2G4/LArWheelSolidDDProxy.h"
#include "GeoSpecialShapes/LArCustomShape.h"
......@@ -59,52 +60,72 @@ typedef std::map<const GeoShape*, G4VSolid*, std::less<const GeoShape*> > shapes
typedef std::map<std::string, G4VSolid*,std::less<std::string> > customSolidMap;
const Geo2G4SolidFactory::LArWheelSolid_typemap Geo2G4SolidFactory::s_lwsTypes = {
/* entries w/o explicit Pos/Neg kept for backward compatibility */
{ "LAr::EMEC::InnerWheel::Absorber", {InnerAbsorberWheel, 1} },
{ "LAr::EMEC::Pos::InnerWheel::Absorber", {InnerAbsorberWheel, 1} },
{ "LAr::EMEC::InnerWheel::Electrode", {InnerElectrodWheel, 1} },
{ "LAr::EMEC::InnerWheel::Glue", {InnerGlueWheel, 1} },
{ "LAr::EMEC::InnerWheel::Lead", {InnerLeadWheel, 1} },
{ "LAr::EMEC::OuterWheel::Absorber", {OuterAbsorberWheel, 1} },
{ "LAr::EMEC::Pos::OuterWheel::Absorber", {OuterAbsorberWheel, 1} },
{ "LAr::EMEC::OuterWheel::Electrode", {OuterElectrodWheel, 1} },
{ "LAr::EMEC::OuterWheel::Glue", {OuterGlueWheel, 1} },
{ "LAr::EMEC::OuterWheel::Lead", {OuterLeadWheel, 1} },
{ "LAr::EMEC::InnerWheel::Electrode", {InnerElectrodWheel, 1} },
{ "LAr::EMEC::Pos::InnerWheel::Absorber", {InnerAbsorberWheel, 1} },
{ "LAr::EMEC::Pos::InnerWheel::Electrode", {InnerElectrodWheel, 1} },
{ "LAr::EMEC::Pos::InnerWheel::Glue", {InnerGlueWheel, 1} },
{ "LAr::EMEC::Pos::InnerWheel::Lead", {InnerLeadWheel, 1} },
{ "LAr::EMEC::OuterWheel::Electrode", {OuterElectrodWheel, 1} },
{ "LAr::EMEC::Pos::OuterWheel::Absorber", {OuterAbsorberWheel, 1} },
{ "LAr::EMEC::Pos::OuterWheel::Electrode", {OuterElectrodWheel, 1} },
{ "LAr::EMEC::Pos::OuterWheel::Glue", {OuterGlueWheel, 1} },
{ "LAr::EMEC::Pos::OuterWheel::Lead", {OuterLeadWheel, 1} },
{ "LAr::EMEC::Neg::InnerWheel::Absorber", {InnerAbsorberWheel, -1} },
{ "LAr::EMEC::Neg::OuterWheel::Absorber", {OuterAbsorberWheel, -1} },
{ "LAr::EMEC::Neg::InnerWheel::Electrode", {InnerElectrodWheel, -1} },
{ "LAr::EMEC::Neg::InnerWheel::Glue", {InnerGlueWheel, -1} },
{ "LAr::EMEC::Neg::InnerWheel::Lead", {InnerLeadWheel, -1} },
{ "LAr::EMEC::Neg::OuterWheel::Absorber", {OuterAbsorberWheel, -1} },
{ "LAr::EMEC::Neg::OuterWheel::Electrode", {OuterElectrodWheel, -1} },
{ "LAr::EMEC::Neg::OuterWheel::Glue", {OuterGlueWheel, -1} },
{ "LAr::EMEC::Neg::OuterWheel::Lead", {OuterLeadWheel, -1} },
{ "LAr::EMEC::InnerModule::Absorber", {InnerAbsorberModule, 1} },
{ "LAr::EMEC::OuterModule::Absorber", {OuterAbsorberModule, 1} },
{ "LAr::EMEC::InnerModule::Electrode", {InnerElectrodModule, 1} },
{ "LAr::EMEC::OuterModule::Absorber", {OuterAbsorberModule, 1} },
{ "LAr::EMEC::OuterModule::Electrode", {OuterElectrodModule, 1} },
{ "LAr::EMEC::InnerWheel::Glue", {InnerGlueWheel, 1} },
{ "LAr::EMEC::Pos::InnerWheel::Glue", {InnerGlueWheel, 1} },
{ "LAr::EMEC::InnerWheel::Lead", {InnerLeadWheel, 1} },
{ "LAr::EMEC::Pos::InnerWheel::Lead", {InnerLeadWheel, 1} },
{ "LAr::EMEC::Pos::InnerCone::Absorber", {InnerAbsorberCone, 1} },
{ "LAr::EMEC::Pos::InnerCone::Electrode", {InnerElectrodCone, 1} },
{ "LAr::EMEC::Pos::InnerCone::Glue", {InnerGlueCone, 1} },
{ "LAr::EMEC::Pos::InnerCone::Lead", {InnerLeadCone, 1} },
{ "LAr::EMEC::OuterWheel::Glue", {OuterGlueWheel, 1} },
{ "LAr::EMEC::Pos::OuterWheel::Glue", {OuterGlueWheel, 1} },
{ "LAr::EMEC::Neg::InnerCone::Absorber", {InnerAbsorberCone, -1} },
{ "LAr::EMEC::Neg::InnerCone::Electrode", {InnerElectrodCone, -1} },
{ "LAr::EMEC::Neg::InnerCone::Glue", {InnerGlueCone, -1} },
{ "LAr::EMEC::Neg::InnerCone::Lead", {InnerLeadCone, -1} },
{ "LAr::EMEC::OuterWheel::Lead", {OuterLeadWheel, 1} },
{ "LAr::EMEC::Pos::OuterWheel::Lead", {OuterLeadWheel, 1} },
{ "LAr::EMEC::Pos::OuterFrontCone::Absorber", {OuterAbsorberFrontCone, 1} },
{ "LAr::EMEC::Pos::OuterFrontCone::Electrode", {OuterElectrodFrontCone, 1} },
{ "LAr::EMEC::Pos::OuterFrontCone::Glue", {OuterGlueFrontCone, 1} },
{ "LAr::EMEC::Pos::OuterFrontCone::Lead", {OuterLeadFrontCone, 1} },
{ "LAr::EMEC::Neg::InnerWheel::Glue", {InnerGlueWheel, -1} },
{ "LAr::EMEC::Neg::OuterFrontCone::Absorber", {OuterAbsorberFrontCone, -1} },
{ "LAr::EMEC::Neg::OuterFrontCone::Electrode", {OuterElectrodFrontCone, -1} },
{ "LAr::EMEC::Neg::OuterFrontCone::Glue", {OuterGlueFrontCone, -1} },
{ "LAr::EMEC::Neg::OuterFrontCone::Lead", {OuterLeadFrontCone, -1} },
{ "LAr::EMEC::Neg::OuterWheel::Glue", {OuterGlueWheel, -1} },
{ "LAr::EMEC::Pos::OuterBackCone::Absorber", {OuterAbsorberBackCone, 1} },
{ "LAr::EMEC::Pos::OuterBackCone::Electrode", {OuterElectrodBackCone, 1} },
{ "LAr::EMEC::Pos::OuterBackCone::Glue", {OuterGlueBackCone, 1} },
{ "LAr::EMEC::Pos::OuterBackCone::Lead", {OuterLeadBackCone, 1} },
{ "LAr::EMEC::Neg::InnerWheel::Lead", {InnerLeadWheel, -1} },
{ "LAr::EMEC::Neg::OuterBackCone::Absorber", {OuterAbsorberBackCone, -1} },
{ "LAr::EMEC::Neg::OuterBackCone::Electrode", {OuterElectrodBackCone, -1} },
{ "LAr::EMEC::Neg::OuterBackCone::Glue", {OuterGlueBackCone, -1} },
{ "LAr::EMEC::Neg::OuterBackCone::Lead", {OuterLeadBackCone, -1} }
{ "LAr::EMEC::Neg::OuterWheel::Lead", {OuterLeadWheel, -1} }
};
Geo2G4SolidFactory::Geo2G4SolidFactory()
......@@ -497,12 +518,15 @@ G4VSolid *Geo2G4SolidFactory::Build(const GeoShape* geoShape, std::string name)
//
// Custom Shapes (presently LAr shapes only)
//
//LAr custom shape
// GeoUnidentifiedShape - LAr custom shape
else if(geoShape->typeID() == GeoUnidentifiedShape::getClassTypeID())
{
const GeoUnidentifiedShape* customShape = dynamic_cast<const GeoUnidentifiedShape*> (geoShape);
//std::cout<<" GeoModelG4, I found a GeoUnidentifiedShape with customShape->name()== " <<customShape->name()<<std::endl;
//const LArCustomShape* customShape = dynamic_cast<const LArCustomShape*> (geoShape);
if (nullptr==customShape) throw std::runtime_error("TypeID did not match cast for custom shape");
if (customShape->name()=="LArCustomShape") {
if (customShape->name()=="LArCustomShape")
{
std::string customName = customShape->asciiData();
customSolidMap::const_iterator it = customSolids.find(customName);
if(it!=customSolids.end())
......@@ -510,58 +534,25 @@ G4VSolid *Geo2G4SolidFactory::Build(const GeoShape* geoShape, std::string name)
else
{
theSolid = nullptr;
if(customName == "LAr::EMEC::InnerWheel::Absorber" || customName == "LAr::EMEC::Pos::InnerWheel::Absorber"){
theSolid = new LArWheelSolid(customName, InnerAbsorberWheel, 1);
} else if(customName == "LAr::EMEC::OuterWheel::Absorber" || customName == "LAr::EMEC::Pos::OuterWheel::Absorber"){
theSolid = new LArWheelSolid(customName, OuterAbsorberWheel, 1);
} else if(customName == "LAr::EMEC::InnerWheel::Electrode" || customName == "LAr::EMEC::Pos::InnerWheel::Electrode"){
theSolid = new LArWheelSolid(customName, InnerElectrodWheel, 1);
} else if(customName == "LAr::EMEC::OuterWheel::Electrode" || customName == "LAr::EMEC::Pos::OuterWheel::Electrode"){
theSolid = new LArWheelSolid(customName, OuterElectrodWheel, 1);
} else if(customName == "LAr::EMEC::Neg::InnerWheel::Absorber"){
theSolid = new LArWheelSolid(customName, InnerAbsorberWheel, -1);
} else if(customName == "LAr::EMEC::Neg::OuterWheel::Absorber"){
theSolid = new LArWheelSolid(customName, OuterAbsorberWheel, -1);
} else if(customName == "LAr::EMEC::Neg::InnerWheel::Electrode"){
theSolid = new LArWheelSolid(customName, InnerElectrodWheel, -1);
} else if(customName == "LAr::EMEC::Neg::OuterWheel::Electrode"){
theSolid = new LArWheelSolid(customName, OuterElectrodWheel, -1);
} else if(customName == "LAr::EMEC::InnerModule::Absorber"){
theSolid = new LArWheelSolid(customName, InnerAbsorberModule, 1);
} else if(customName == "LAr::EMEC::OuterModule::Absorber"){
theSolid = new LArWheelSolid(customName, OuterAbsorberModule, 1);
} else if(customName == "LAr::EMEC::InnerModule::Electrode"){
theSolid = new LArWheelSolid(customName, InnerElectrodModule, 1);
} else if(customName == "LAr::EMEC::OuterModule::Electrode"){
theSolid = new LArWheelSolid(customName, OuterElectrodModule, 1);
} else if(customName == "LAr::EMEC::InnerWheel::Glue" || customName == "LAr::EMEC::Pos::InnerWheel::Glue"){
theSolid = new LArWheelSolid(customName, InnerGlueWheel, 1);
} else if(customName == "LAr::EMEC::InnerWheel::Lead" || customName == "LAr::EMEC::Pos::InnerWheel::Lead"){
theSolid = new LArWheelSolid(customName, InnerLeadWheel, 1);
} else if(customName == "LAr::EMEC::OuterWheel::Glue" || customName == "LAr::EMEC::Pos::OuterWheel::Glue"){
theSolid = new LArWheelSolid(customName, OuterGlueWheel, 1);
} else if(customName == "LAr::EMEC::OuterWheel::Lead" || customName == "LAr::EMEC::Pos::OuterWheel::Lead"){
theSolid = new LArWheelSolid(customName, OuterLeadWheel, 1);
} else if(customName == "LAr::EMEC::Neg::InnerWheel::Glue"){
theSolid = new LArWheelSolid(customName, InnerGlueWheel, -1);
} else if(customName == "LAr::EMEC::Neg::InnerWheel::Lead"){
theSolid = new LArWheelSolid(customName, InnerLeadWheel, -1);
} else if(customName == "LAr::EMEC::Neg::OuterWheel::Glue"){
theSolid = new LArWheelSolid(customName, OuterGlueWheel, -1);
} else if(customName == "LAr::EMEC::Neg::OuterWheel::Lead"){
theSolid = new LArWheelSolid(customName, OuterLeadWheel, -1);
}
if(customName.find("Slice") != std::string::npos){
//const LArCustomShape* larShape = dynamic_cast<const LArCustomShape*> (customShape);
theSolid = createLArWheelSliceSolid(customShape);
} else {
theSolid = createLArWheelSolid(customName, s_lwsTypes.at(customName) ); // map.at throws std::out_of_range exception on unknown shape name
}
if ( nullptr == theSolid ) {
std::string error = std::string("Can't create LArWheelSolid for name ") + customName + " in Geo2G4SolidFactory::Build";
throw std::runtime_error(error);
}
if(theSolid != nullptr) customSolids[customName] = theSolid;
}
}
}
//
// Catch All
//
......@@ -591,3 +582,16 @@ G4VSolid* Geo2G4SolidFactory::createLArWheelSolid(const std::string& name, const
//}
return theLWS;
}
G4VSolid* Geo2G4SolidFactory::createLArWheelSliceSolid(const GeoUnidentifiedShape* customShape) const
{
LArWheelSliceSolid *theLWS = new LArWheelSliceSolid(customShape->asciiData() );
//LArWheelSolidDDProxy *theLWS_p = new LArWheelSolidDDProxy(theLWS);
// ownership is passed to detStore
// if(detStore()->record(theLWS_p, theLWS->GetName()).isFailure()){
// ATH_MSG_WARNING("Can't store proxy for LArWheelSolid to the DetectorStore");
// delete theLWS_p;
// }
return theLWS;
}
GeoModel2G4/src/LArWheelSliceSolidInit.cxx
+ 2
− 2
View file @ 7a407059
......@@ -38,8 +38,8 @@ LArWheelSliceSolid::LArWheelSliceSolid(
createSolid(name, zside, slice);
}
LArWheelSliceSolid::LArWheelSliceSolid(const G4String& name, const LArWheelCalculator *calc)
: G4VSolid(name), m_Calculator(calc)/*, m_msg("LArWSS")*/
LArWheelSliceSolid::LArWheelSliceSolid(const G4String& name)
: G4VSolid(name), m_Calculator(0)/*, m_msg("LArWSS")*/
{
if(name.find("::Inner") != G4String::npos) m_Pos = Inner;
else if(name.find("::Outer") != G4String::npos) m_Pos = Outer;
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please to comment