LArWheelSliceSolid Class Reference

#include <LArWheelSliceSolid.h>

Inheritance diagram for LArWheelSliceSolid:

Collaboration diagram for LArWheelSliceSolid:

Public Types
enum	pos_t { Inner , Outer }
enum	type_t { Absorber , Electrode , Glue , Lead }

Public Member Functions
	LArWheelSliceSolid (const G4String &name, pos_t pos, type_t type, size_t slice, G4int zside=1, const LArWheelCalculator *calc=0, const EMECData *emecData=0)
	LArWheelSliceSolid (const G4String &name, const EMECData *emecData)
virtual	~LArWheelSliceSolid ()
EInside	Inside (const G4ThreeVector &) const
G4double	DistanceToIn (const G4ThreeVector &, const G4ThreeVector &) const
G4double	DistanceToIn (const G4ThreeVector &) const
G4double	DistanceToOut (const G4ThreeVector &, const G4ThreeVector &, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const
G4double	DistanceToOut (const G4ThreeVector &) const
G4ThreeVector	SurfaceNormal (const G4ThreeVector &) const
G4bool	CalculateExtent (const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &) const
G4GeometryType	GetEntityType () const
void	DescribeYourselfTo (G4VGraphicsScene &) const
G4VisExtent	GetExtent () const
G4Polyhedron *	CreatePolyhedron () const
virtual std::ostream &	StreamInfo (std::ostream &os) const
G4ThreeVector	GetPointOnSurface (void) const
G4double	GetCubicVolume (void)
G4double	GetSurfaceArea (void)
const G4VSolid *	GetBoundingShape (void) const
const LArWheelCalculator *	GetCalculator (void) const
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Protected Attributes
TF1 *	m_f_area
TF1 *	m_f_vol
TF1 *	m_f_area_on_pc
TF1 *	m_f_length
TF1 *	m_f_side_area
double	m_test_index

Private Member Functions
void	inner_solid_init (const G4String &, size_t slice)
void	outer_solid_init (const G4String &, size_t slice)
void	fill_zsect (std::vector< G4double > &, G4double zMid=0.) const
virtual G4double	distance_to_in (G4ThreeVector &, const G4ThreeVector &, int) const
G4double	in_iteration_process (const G4ThreeVector &, G4double, G4ThreeVector &, int) const
G4double	search_for_nearest_point (const G4ThreeVector &, const G4double, const G4ThreeVector &, int) const
G4bool	search_for_most_remoted_point (const G4ThreeVector &, const G4ThreeVector &, G4ThreeVector &, const int) const
G4double	out_iteration_process (const G4ThreeVector &, G4ThreeVector &, const int) const
EInside	Inside_accordion (const G4ThreeVector &) const
void	get_point_on_accordion_surface (G4ThreeVector &) const
void	get_point_on_polycone_surface (G4ThreeVector &) const
void	get_point_on_flat_surface (G4ThreeVector &) const
void	set_failover_point (G4ThreeVector &p, const char *m=0) const
G4double	get_area_on_polycone (void) const
G4double	get_area_on_face (void) const
G4double	get_area_on_side (void) const
G4double	get_area_at_r (G4double r) const
G4double	get_length_at_r (G4double r) const
void	test (void)
void	clean_tests (void)
void	init_tests (void)
G4String	TypeStr (void) const
void	createSolid (const G4String &name, G4int zside, size_t slice, const EMECData *emecData)
void	check_slice (size_t size, size_t slice) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
pos_t	m_Pos {}
type_t	m_Type {}
const LArWheelCalculator *	m_Calculator {}
G4VSolid *	m_BoundingShape {}
G4double	m_FanHalfThickness {}
G4double	m_FHTplusT {}
G4double	m_FHTminusT {}
G4double	m_Xmin {}
G4double	m_Xmax {}
G4double	m_Ymin {}
G4double	m_Zmin {}
G4double	m_Zmax {}
G4double	m_Rmin {}
G4double	m_Rmax {}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Static Private Attributes
static const G4double	s_Tolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance() / 2
static const G4double	s_AngularTolerance = G4GeometryTolerance::GetInstance()->GetAngularTolerance() / 2
static const G4double	s_IterationPrecision = 0.001*CLHEP::mm
static const G4double	s_IterationPrecision2 = s_IterationPrecision * s_IterationPrecision
static const unsigned int	s_IterationsLimit = 50

Friends
double	LArWheelSliceSolid_fcn_area (double *x, double *p)
double	LArWheelSliceSolid_fcn_vol (double *x, double *p)
double	LArWheelSliceSolid_fcn_area_on_pc (double *x, double *p)
double	LArWheelSliceSolid_get_dl (double *x, double *par, G4int side)
double	LArWheelSliceSolid_fcn_side_area (double *x, double *p)

Detailed Description

Definition at line 42 of file LArWheelSliceSolid.h.

Member Enumeration Documentation

pos_t

enum LArWheelSliceSolid::pos_t

Enumerator
Inner
Outer

Definition at line 48 of file LArWheelSliceSolid.h.

{ Inner, Outer } pos_t;

type_t

enum LArWheelSliceSolid::type_t

Enumerator
Absorber
Electrode
Glue
Lead

Definition at line 49 of file LArWheelSliceSolid.h.

{ Absorber, Electrode, Glue, Lead } type_t;

Constructor & Destructor Documentation

LArWheelSliceSolid() [1/2]

LArWheelSliceSolid::LArWheelSliceSolid	(	const G4String &	name,
		pos_t	pos,
		type_t	type,
		size_t	slice,
		G4int	zside = 1,
		const LArWheelCalculator *	calc = 0,
		const EMECData *	emecData = 0 )

Definition at line 47 of file LArWheelSliceSolidInit.cxx.

  : G4VSolid(name)
#ifndef PORTABLE_LAR_SHAPE
  , AthMessaging("LArWSS")
#endif
  , m_Pos(pos), m_Type(type), m_Calculator(calc)
{
  createSolid(name, zside, slice, emecData);
}

LArWheelSliceSolid() [2/2]

LArWheelSliceSolid::LArWheelSliceSolid	(	const G4String &	name,
		const EMECData *	emecData )

Definition at line 62 of file LArWheelSliceSolidInit.cxx.

  : G4VSolid(name)
#ifndef PORTABLE_LAR_SHAPE    
  , AthMessaging("LArWSS")
#endif
  , m_Calculator(0)
{
    if(name.find("::Inner") != G4String::npos) m_Pos = Inner;
    else if(name.find("::Outer") != G4String::npos) m_Pos = Outer;
    else G4Exception(
        "LArWheelSliceSolid", "NoPos", FatalException,
        (std::string("Constructor: can't get Inner/Outer from ") + name).c_str()
    );
 
    if(name.find("::Absorber") != G4String::npos) m_Type = Absorber;
    else if(name.find("::Electrode") != G4String::npos) m_Type = Electrode;
    else if(name.find("::Glue") != G4String::npos) m_Type = Glue;
    else if(name.find("::Lead") != G4String::npos) m_Type = Lead;
    else G4Exception(
        "LArWheelSliceSolid", "NoType", FatalException,
        (std::string("Constructor: can't get Type from ") + name).c_str()
    );
 
    size_t s = name.find("Slice");
    size_t slice = 0;
    if(G4String::npos != s){
        slice = (size_t) atoi(name.substr(s + 5, 2).c_str());
    } else G4Exception(
        "LArWheelSliceSolid", "NoSlice", FatalException,
        (std::string("Constructor: can't get Slice from ") + name).c_str()
    );
 
    G4int zside = 0;
    if(name.find("::Pos::") != G4String::npos) zside = 1;
    else if(name.find("::Neg::") != G4String::npos) zside = -1;
    else G4Exception(
        "LArWheelSliceSolid", "NoSide", FatalException,
        (std::string("Constructor: can't get zSide from ") + name).c_str()
    );
    createSolid(name, zside, slice, emecData);
}

~LArWheelSliceSolid()

virtual LArWheelSliceSolid::~LArWheelSliceSolid ( )

inlinevirtual

Definition at line 59 of file LArWheelSliceSolid.h.

{}

Member Function Documentation

CalculateExtent()

G4bool LArWheelSliceSolid::CalculateExtent	(	const EAxis	a,
		const G4VoxelLimits &	vl,
		const G4AffineTransform &	t,
		G4double &	p,
		G4double &	q ) const

Definition at line 58 of file LArWheelSliceSolid.cxx.

{
    return m_BoundingShape->CalculateExtent(a, vl, t, p, q);
}

check_slice()

void LArWheelSliceSolid::check_slice ( size_t size, size_t slice ) const

inlineprivate

Definition at line 183 of file LArWheelSliceSolidInit.cxx.

{
    if(size <= slice + 1){
        G4Exception(
            "LArWheelSliceSolid", "WrongSlice", FatalException,
            std::string("Constructor: Slice number too big: " + GetName()).c_str()
        );
    }
}

clean_tests()

void LArWheelSliceSolid::clean_tests ( void )

private

Definition at line 484 of file LArWheelSliceSolidTests.cxx.

                                         {
    if(m_f_area) {
        delete m_f_area;
          m_f_area = 0;
    }
    if(m_f_vol) {
        delete m_f_vol;
        m_f_vol = 0;
    }
 
    if(m_f_area_on_pc) {
        delete m_f_area_on_pc;
        m_f_area_on_pc = 0;
    }
 
    if(m_f_length) {
        delete m_f_length;
        m_f_length = 0;
    }
    if(m_f_side_area) {
        delete m_f_side_area;
        m_f_side_area = 0;
    }
}

CreatePolyhedron()

G4Polyhedron * LArWheelSliceSolid::CreatePolyhedron

(

)

const

Definition at line 101 of file LArWheelSliceSolid.cxx.

{
    return m_BoundingShape->CreatePolyhedron();
}

createSolid()

void LArWheelSliceSolid::createSolid ( const G4String & name, G4int zside, size_t slice, const EMECData * emecData )

private

Definition at line 104 of file LArWheelSliceSolidInit.cxx.

{
#ifndef PORTABLE_LAR_SHAPE
    m_f_area = m_f_vol = m_f_area_on_pc = m_f_length = m_f_side_area = 0;
#endif
    
    LArG4::LArWheelCalculator_t calc_type = LArG4::LArWheelCalculator_t(0);
    switch(m_Pos){
    case Inner:
        switch(m_Type){
        case Absorber: calc_type = LArG4::InnerAbsorberWheel; break;
        case Electrode: calc_type = LArG4::InnerElectrodWheel; break;
        case Glue: calc_type = LArG4::InnerGlueWheel; break;
        case Lead: calc_type = LArG4::InnerLeadWheel; break;
        }
        break;
    case Outer:
        switch(m_Type){
        case Absorber: calc_type = LArG4::OuterAbsorberWheel; break;
        case Electrode: calc_type = LArG4::OuterElectrodWheel; break;
        case Glue: calc_type = LArG4::OuterGlueWheel; break;
        case Lead: calc_type = LArG4::OuterLeadWheel; break;
        }
        break;
    }
    if(m_Calculator == 0) {
      m_Calculator = new LArWheelCalculator(*emecData, calc_type, zside);
 
    }
    else if(m_Calculator->type() != calc_type){
        G4Exception(
            "LArWheelSliceSolid", "WrongCalculatorType", FatalException,
            "Constructor: external LArWheelCalculator of wrong type provided"
        );
    }
 
    const G4String bs_name = name + "-Bounding";
 
#ifdef DEBUG_LARWHEELSLICESOLID
    const char *venv = getenv("LARWHEELSLICESOLID_VERBOSE");
    if(venv) Verbose = atoi(venv);
    static bool first = true;
    if(first){
        std::cout << "The LArWheelSliceSolid build "
                  << __DATE__ << " " << __TIME__  << std::endl
                  << "LArWheelSliceSolid verbosity level is "
                  << Verbose << std::endl;
        first = false;
    }
#endif
 
    m_FanHalfThickness = GetCalculator()->GetFanHalfThickness();
    m_FHTplusT = m_FanHalfThickness + s_Tolerance;
    m_FHTminusT = m_FanHalfThickness - s_Tolerance;
 
    switch(m_Pos){
    case Inner: inner_solid_init(bs_name, slice); break;
    case Outer: outer_solid_init(bs_name, slice); break;
    }
#ifndef PORTABLE_LAR_SHAPE
    ATH_MSG_DEBUG(m_BoundingShape->GetName() + " is the m_BoundingShape");
 
    init_tests();
    test(); // activated by env. variable
    clean_tests();
 
    ATH_MSG_DEBUG("slice " << m_Pos << " "  << m_Type
          << " " << slice << " initialized" << endmsg);
 
#endif
    
 #ifdef DEBUG_LARWHEELSLICESOLID
    std::cout << "LArWSS(" << m_Pos << ", " << m_Type
              << "): slice " << slice << ", Zmin = " << m_Zmin
              << ", Zmax = " << m_Zmax << std::endl
              << GetName() << std::endl;
#endif
}

DescribeYourselfTo()

void LArWheelSliceSolid::DescribeYourselfTo

(

G4VGraphicsScene &

scene

)

const

Definition at line 91 of file LArWheelSliceSolid.cxx.

{
    scene.AddSolid(*this);
}

distance_to_in()

G4double LArWheelSliceSolid::distance_to_in ( G4ThreeVector & p, const G4ThreeVector & v, int p_fan ) const

privatevirtual

Definition at line 121 of file LArWheelSliceSolidDisToIn.cxx.

{
    LWSDBG(4, std::cout << "dti:           " << MSG_VECTOR(p) << " "
                        << MSG_VECTOR(v) << std::endl);
 
    G4double distance = 0.;
 
    if(p.x() > m_Xmax) {
        if(v.x() >= 0.) return kInfinity;
        const G4double b = (m_Xmax - p.x()) / v.x();
        const G4double y2 = p.y() + v.y() * b;
        const G4double z2 = p.z() + v.z() * b;
        p.set(m_Xmax, y2, z2);
        distance += b;
    } else if(p.x() < m_Xmin) {
        if(v.x() <= 0.)    return kInfinity;
        const G4double b = (m_Xmin - p.x()) / v.x();
        const G4double y2 = p.y() + v.y() * b;
        const G4double z2 = p.z() + v.z() * b;
        p.set(m_Xmin, y2, z2);
        distance += b;
    }
 
// here p is on surface of or inside the "FanBound",
// distance corrected, misses are accounted for
    LWSDBG(5, std::cout << "dti corrected: " << MSG_VECTOR(p) << std::endl);
 
    G4double dist_p = GetCalculator()->DistanceToTheNeutralFibre(p, p_fan);
    if(fabs(dist_p) < m_FHTminusT) {
        LWSDBG(5, std::cout << "hit fan dist_p=" << dist_p << ", m_FHTminusT=" << m_FHTminusT << std::endl);
        return distance;
    }
 
    G4ThreeVector q;
    q = p + v * m_BoundingShape->DistanceToOut(p, v);
    G4double dist_q = GetCalculator()->DistanceToTheNeutralFibre(q, p_fan);
    LWSDBG(5, std::cout << "dti exit point: " << MSG_VECTOR(q) << " "
                        << dist_q << std::endl);
    G4double dd = kInfinity;
    if(dist_p * dist_q < 0.){// it certanly cross current half-wave
        dd = in_iteration_process(p, dist_p, q, p_fan);
    }
    G4double d2 = search_for_nearest_point(p, dist_p, q, p_fan);
    if(d2 < kInfinity){
        return distance + d2; // this half-wave is intersected
    } else if(dd < kInfinity){
        return distance + dd;
    }
    return kInfinity;
}

DistanceToIn() [1/2]

G4double LArWheelSliceSolid::DistanceToIn

(

const G4ThreeVector &

inputP

)

const

Definition at line 15 of file LArWheelSliceSolidDisToIn.cxx.

{
    LWSDBG(1, std::cout << TypeStr() << " DisToIn" << MSG_VECTOR(inputP) << std::endl);
    if(m_BoundingShape->Inside(inputP) == kOutside) {
    // here is an approximation - for the point outside m_BoundingShape
    // the solid looks like a m_BoundingShape
    // it's okay since the result could be underestimated
        LWSDBG(2, std::cout << "Outside BS" << std::endl);
        return m_BoundingShape->DistanceToIn(inputP);
    }
    G4ThreeVector p(inputP);
 
    //
    // DistanceToTheNearestFan:
    // rotates point p to the localFan coordinates and returns fan number to out_fan_number parameter
    // returns distance to fan as result
    //
 
    int p_fan = 0;
    const G4double d = fabs(GetCalculator()->DistanceToTheNearestFan(p, p_fan));
    if(d > m_FHTplusT){
        const G4double result = d - m_FanHalfThickness;
        LWSDBG(2, std::cout << "dti result = " << result << std::endl);
        return result;
    }
    LWSDBG(2, std::cout << "already inside, return 0" << MSG_VECTOR(p) << std::endl);
    return 0.;
}

DistanceToIn() [2/2]

G4double LArWheelSliceSolid::DistanceToIn	(	const G4ThreeVector &	inputP,
		const G4ThreeVector &	inputV ) const

Definition at line 44 of file LArWheelSliceSolidDisToIn.cxx.

{
    LWSDBG(1, std::cout << TypeStr() << " DisToIn" << MSG_VECTOR(inputP)
                        << MSG_VECTOR(inputV) << std::endl);
 
    G4double distance = 0.;
    const EInside inside_BS = m_BoundingShape->Inside(inputP);
    G4ThreeVector p(inputP);
    if(inside_BS == kOutside) {
        distance = m_BoundingShape->DistanceToIn(inputP, inputV);
        if(distance == kInfinity) {
            LWSDBG(2, std::cout << "Infinity distance to m_BoundingShape"
                                << MSG_VECTOR(inputP) << MSG_VECTOR(inputV)
                                << std::endl);
            return kInfinity;
        }
        p += inputV * distance;
        assert(m_BoundingShape->Inside(p) != kOutside);
        LWSDBG(2, std::cout << "shift" << MSG_VECTOR(inputP) << std::endl);
    }
 
    const G4double phi0 = p.phi();
    int p_fan = 0;
    const G4double d = GetCalculator()->DistanceToTheNearestFan(p, p_fan);
    if(fabs(d) < m_FHTminusT){
        LWSDBG(2, std::cout << "already inside fan" << MSG_VECTOR(p) << std::endl);
        // if initial point is on BS surface and inside fan volume it is a real surface
        if(inside_BS == kSurface) {
            LWSDBG(2, std::cout << "On BS surface" << std::endl);
            return m_BoundingShape->DistanceToIn(inputP, inputV);
        }
        return distance;
    }
    G4ThreeVector v(inputV);
    v.rotateZ(p.phi() - phi0);
 
    const G4double d0 = distance_to_in(p, v, p_fan);
    distance += d0;
 
#ifdef DEBUG_LARWHEELSLICESOLID
    if(Verbose > 2){
        if(Verbose > 3){
            std::cout << MSG_VECTOR(inputP)
                      << " " << MSG_VECTOR(inputV) << std::endl;
        }
        std::cout << "dti: " << d0 << ", DTI: " << distance << std::endl;
    }
    if(Verbose > 3){
        if(d0 < kInfinity){
            G4ThreeVector p2 = inputP + inputV*distance;
            EInside i = Inside(p2);
            std::cout << "DTI hit at dist. " << distance << ", point "
                      << MSG_VECTOR(p2) << ", "
                      << inside(i) << std::endl;
        } else {
            std::cout << "got infinity from dti" << std::endl;
        }
    }
#ifdef LWS_HARD_TEST_DTI
    if(test_dti(inputP, inputV, distance)){
        if(Verbose == 1){
            std::cout << TypeStr() << " DisToIn" << MSG_VECTOR(inputP)
                      << MSG_VECTOR(inputV) << std::endl;
        }
    }
    if(Verbose == 1){
        std::cout << TypeStr() << " DisToIn" << MSG_VECTOR(inputP)
                  << MSG_VECTOR(inputV) << " " << distance << std::endl;
    }
#endif // ifdef LWS_HARD_TEST_DTI
 
#endif // ifdef DEBUG_LARWHEELSLICESOLID
 
  return distance;
}

DistanceToOut() [1/2]

G4double LArWheelSliceSolid::DistanceToOut

(

const G4ThreeVector &

inputP

)

const

Definition at line 10 of file LArWheelSliceSolidDisToOut.cxx.

{
    LWSDBG(1, std::cout << TypeStr() << " DisToOut" << MSG_VECTOR(inputP) << std::endl);
    if(m_BoundingShape->Inside(inputP) != kInside){
        LWSDBG(2, std::cout << "DistanceToOut(p):"
                            << " point " << MSG_VECTOR(inputP)
                            << " is not inside of the m_BoundingShape."
                            << std::endl);
        return 0.;
    }
    G4ThreeVector p(inputP);
    int p_fan = 0;
    const G4double d = m_FanHalfThickness - fabs(GetCalculator()->DistanceToTheNearestFan(p, p_fan));
    if(d < s_Tolerance){
        LWSDBG(2, std::cout << "already not inside " << MSG_VECTOR(p) << std::endl);
        return 0.;
    }
    const G4double d0 = m_BoundingShape->DistanceToOut(inputP);
    LWSDBG(2, std::cout << "dto " << d << " " << d0 << std::endl);
    if(d > d0) return d0;
    else return d;
}

DistanceToOut() [2/2]

G4double LArWheelSliceSolid::DistanceToOut	(	const G4ThreeVector &	inputP,
		const G4ThreeVector &	inputV,
		const G4bool	calcNorm = false,
		G4bool *	validNorm = 0,
		G4ThreeVector *	n = 0 ) const

Definition at line 33 of file LArWheelSliceSolidDisToOut.cxx.

{
    LWSDBG(1, std::cout << TypeStr() << " DisToOut" << MSG_VECTOR(inputP)
                        << MSG_VECTOR(inputV) << std::endl);
 
    const EInside inside_BS = m_BoundingShape->Inside(inputP);
    if(inside_BS == kOutside){
        LWSDBG(2, std::cout << "DistanceToOut(p):"
                            << " point " << MSG_VECTOR(inputP)
                            << " is outside of m_BoundingShape." << std::endl);
        if(calcNorm) *validNorm = false;
        return 0.;
    }
 
    // If here inside or on surface of BS
    G4ThreeVector p(inputP);
    int p_fan = 0;
    const G4double adtnf_p = fabs(GetCalculator()->DistanceToTheNearestFan(p, p_fan));
    if(adtnf_p >= m_FHTplusT) {
        LWSDBG(2, std::cout << "DistanceToOut(p, v): point "
                            << MSG_VECTOR(inputP)
                            << " is outside of solid." << std::endl);
        if(calcNorm) *validNorm = false;
        return 0.;
    }
 
    G4ThreeVector v(inputV);
    const G4double phi0 = p.phi() - inputP.phi();
    v.rotateZ(phi0);
 
// former distance_to_out starts here
    LWSDBG(4, std::cout << "dto: " << MSG_VECTOR(p) << " "
                        << MSG_VECTOR(v) << std::endl);
 
    G4ThreeVector q(p);
 
    const G4double dto_bs = m_BoundingShape->DistanceToOut(
        inputP, inputV, calcNorm, validNorm, sn
    );
    q = p + v * dto_bs;
    if(q.y() < m_Ymin){
        LWSDBG(5, std::cout << "dto exit point too low " << MSG_VECTOR(q) << std::endl);
        const G4double dy = (m_Ymin - p.y()) / v.y();
        q.setX(p.x() + v.x() * dy);
        q.setY(m_Ymin);
        q.setZ(p.z() + v.z() * dy);
    }
    LWSDBG(5, std::cout << "dto exit point " << MSG_VECTOR(q) << std::endl);
 
    G4double tmp;
    G4double distance = 0.;
    if(fabs(GetCalculator()->DistanceToTheNeutralFibre(q, p_fan)) > m_FHTplusT){
        LWSDBG(5, std::cout << "q=" << MSG_VECTOR(q)
                            << " outside fan cur distance="
                            << distance << ", m_FHTplusT="
                            << m_FHTplusT << std::endl);
        tmp = out_iteration_process(p, q, p_fan);
    } else {
        tmp = (q - p).mag();
    }
    G4ThreeVector C;
    if(search_for_most_remoted_point(p, q, C, p_fan)){
        tmp = out_iteration_process(p, C, p_fan);
    }
    distance += tmp;
 
    LWSDBG(5, std::cout << "At end_dto distance=" << distance  << std::endl);
    if(calcNorm && distance < dto_bs) *validNorm = false;
 
#ifdef DEBUG_LARWHEELSLICESOLID
    if(Verbose > 2){
        std::cout << "DTO: " << distance << " ";
        if (*validNorm) {
          std::cout << *validNorm << " " << MSG_VECTOR((*sn));
        } else {
          std::cout << "Norm is not valid";
        }
        std::cout << std::endl;
        if(Verbose > 3){
            G4ThreeVector p2 = inputP + inputV * distance;
            EInside i = Inside(p2);
            std::cout << "DTO hit at " << MSG_VECTOR(p2) << ", "
                      << inside(i) << std::endl;
        }
    }
#ifdef LWS_HARD_TEST_DTO
    if(test_dto(inputP, inputV, distance)){
        if(Verbose == 1){
            std::cout << TypeStr() << " DisToOut" << MSG_VECTOR(inputP)
                      << MSG_VECTOR(inputV) << std::endl;
        }
    }
#endif
#endif
    return distance;
}

fill_zsect()

void LArWheelSliceSolid::fill_zsect ( std::vector< G4double > & zsect, G4double zMid = 0. ) const

private

Definition at line 263 of file LArWheelSliceSolidInit.cxx.

{
    const G4double half_wave_length = GetCalculator()->GetHalfWaveLength();
    const G4double sss = GetCalculator()->GetStraightStartSection();
    const G4int num_fs = GetCalculator()->GetNumberOfHalfWaves() + 1;
    const G4double wheel_thickness = GetCalculator()->GetWheelThickness();
 
    zsect.push_back(0.);
    zsect.push_back(sss + half_wave_length * 0.25);
    for(G4int i = 2; i < num_fs; i ++){
        const G4double zi = half_wave_length * (i - 1) + sss;
        if(m_Pos == Outer && zsect.back() < zMid && zi > zMid){
            zsect.push_back(zMid);
        }
        zsect.push_back(zi);
    }
    zsect.push_back(wheel_thickness - sss - half_wave_length * 0.25);
    zsect.push_back(wheel_thickness);
}

get_area_at_r()

G4double LArWheelSliceSolid::get_area_at_r ( G4double r ) const

private

Definition at line 509 of file LArWheelSliceSolidTests.cxx.

{
  m_f_area->SetParameter(0, r);
 
  double zmin = m_BoundingShape->DistanceToIn(
                                               G4ThreeVector(0., r, m_Zmin), G4ThreeVector(0., 0., 1.)
                                               );
  double zmax = m_BoundingShape->DistanceToIn(
                                               G4ThreeVector(0., r, m_Zmax), G4ThreeVector(0., 0., -1.)
                                               );
  zmax = m_Zmax - zmax;
 
  double result = m_f_area->Integral(zmin, zmax);
 
  return result;
}

get_area_on_face()

G4double LArWheelSliceSolid::get_area_on_face ( void ) const

private

Definition at line 334 of file LArWheelSliceSolidTests.cxx.

{
    G4double result = 0.;
    G4double rmin, rmax;
    get_r(m_BoundingShape, m_Zmin, rmin, rmax);
    result += rmax - rmin;
    get_r(m_BoundingShape, m_Zmax, rmin, rmax);
    result += rmax - rmin;
    result *= GetCalculator()->GetFanHalfThickness() * 2.;
    return result;
}

get_area_on_polycone()

G4double LArWheelSliceSolid::get_area_on_polycone ( void ) const

private

Definition at line 329 of file LArWheelSliceSolidTests.cxx.

{
    return m_f_area_on_pc->Integral(m_Zmin, m_Zmax);
}

get_area_on_side()

G4double LArWheelSliceSolid::get_area_on_side ( void ) const

private

Definition at line 362 of file LArWheelSliceSolidTests.cxx.

{
    return m_f_side_area->Integral(m_Rmin, m_Rmax, IntPrecision);
}

get_length_at_r()

G4double LArWheelSliceSolid::get_length_at_r ( G4double r ) const

private

Definition at line 346 of file LArWheelSliceSolidTests.cxx.

{
    m_f_length->SetParameter(0, r);
 
    double zmin = m_BoundingShape->DistanceToIn(
        G4ThreeVector(0., r, -m_Zmin), G4ThreeVector(0., 0., 1.)
    );
    zmin -= m_Zmin * 2.;
    double zmax = m_BoundingShape->DistanceToIn(
        G4ThreeVector(0., r, m_Zmax), G4ThreeVector(0., 0., -1.)
    );
    zmax = m_Zmax - zmax;
    double result = m_f_length->Integral(zmin, zmax);
    return result;
}

get_point_on_accordion_surface()

void LArWheelSliceSolid::get_point_on_accordion_surface ( G4ThreeVector & p ) const

private

Definition at line 101 of file LArWheelSliceSolidTests.cxx.

{
    p[0] = 0.;  p[1] = 0.; p[2] = rnd->Uniform(m_Zmin, m_Zmax);
 
    G4double rmin, rmax;
    get_r(m_BoundingShape, p[2], rmin, rmax);
 
    p[1] = rnd->Uniform(rmin, rmax);
    p.setPhi(rnd->Uniform(0., CLHEP::twopi));
    G4double dphi = p.phi();
    int p_fan = 0;
    G4double d = GetCalculator()->DistanceToTheNearestFan(p, p_fan);
    dphi -= p.phi();
 
    G4int side = 0;
    if(d < 0.) side = -1;
    if(d >= 0.) side = 1;
 
    G4double a = GetCalculator()->AmplitudeOfSurface(p, side, p_fan);
    p[0] = a;
 
    p.rotateZ(dphi);
 
    if(m_BoundingShape->Inside(p) == kOutside){
        G4ThreeVector D = p; D[2] = 0.;
        G4double d1 = m_BoundingShape->DistanceToIn(p, D);
        if(d1 > 10.*CLHEP::m){
            D *= -1;
            d1 = m_BoundingShape->DistanceToIn(p, D);
        }
        if(d1 > 10.*CLHEP::m){
            set_failover_point(p, "acc fail0");
            return;
        }
        d1 *= 2.;
 
        G4ThreeVector B = p + D * d1;
        G4double dphi = B.phi();
        int B_fan = 0;
        GetCalculator()->DistanceToTheNearestFan(B, B_fan);
        dphi -= B.phi();
 
        B[0] = GetCalculator()->AmplitudeOfSurface(B, side, B_fan);
        B.rotateZ(dphi);
        EInside Bi = m_BoundingShape->Inside(B);
        if(Bi == kSurface){
            p = B;
            return;
        }
        if(Bi == kOutside){
            set_failover_point(p, "acc fail1");
            return;
        }
        G4ThreeVector D1 = (p - B).unit();
        G4ThreeVector X = B + D1 * m_BoundingShape->DistanceToOut(B, D1);
        if(Inside(X) == kSurface){
            p = X;
        } else { // failed
            set_failover_point(p, "acc fail2");
            return;
        }
    }
}

get_point_on_flat_surface()

void LArWheelSliceSolid::get_point_on_flat_surface ( G4ThreeVector & p ) const

private

Definition at line 288 of file LArWheelSliceSolidTests.cxx.

{
    p[0] = 0.;
    p[1] = 0.;
    p[2] = rnd->Uniform() > 0.5? m_Zmin: m_Zmax;
 
    G4double rmin, rmax;
    get_r(m_BoundingShape, p[2], rmin, rmax);
 
    p[1] = rnd->Uniform(rmin, rmax);
    p.setPhi(rnd->Uniform(0., CLHEP::twopi));
    G4double dphi = p.phi();
    int p_fan = 0;
    GetCalculator()->DistanceToTheNearestFan(p, p_fan);
    dphi -= p.phi();
 
    p[0] = rnd->Uniform(
        GetCalculator()->AmplitudeOfSurface(p, -1, p_fan),
        GetCalculator()->AmplitudeOfSurface(p, 1, p_fan)
    );
 
    p.rotateZ(dphi);
 
    if(m_BoundingShape->Inside(p) != kSurface){
        set_failover_point(p, "flat fail");
    }
}

get_point_on_polycone_surface()

void LArWheelSliceSolid::get_point_on_polycone_surface ( G4ThreeVector & p ) const

private

Definition at line 165 of file LArWheelSliceSolidTests.cxx.

{
    const G4double z = rnd->Uniform(m_Zmin, m_Zmax);
    G4double rmin, rmax;
    get_r(m_BoundingShape, z, rmin, rmax);
    const bool inner = rnd->Uniform() > 0.5? true: false;
 
    p[0] = 0.; p[1] = inner? rmin: rmax; p[2] = z;
    p.setPhi(rnd->Uniform(0., CLHEP::twopi));
    G4double dphi = p.phi();
    int p_fan = 0;
    GetCalculator()->DistanceToTheNearestFan(p, p_fan);
    dphi -= p.phi();
 
    const G4double r = p[1];
 
    G4ThreeVector A1(0., r, z);
    A1[0] = GetCalculator()->AmplitudeOfSurface(A1, -1, p_fan);
    A1.rotateZ(dphi);
    EInside A1i = m_BoundingShape->Inside(A1);
    //    EInside A1a = Inside_accordion(A1);
    //std::cout << "A1: " << A1i << " " << A1a << std::endl;
    if(A1i == kSurface){
        //std::cout << "got A1" << std::endl;
        p = A1;
        return;
    }
 
    G4ThreeVector A2(0., r, z);
    A2[0] = GetCalculator()->AmplitudeOfSurface(A2, 1, p_fan);
    A2.rotateZ(dphi);
    EInside A2i = m_BoundingShape->Inside(A2);
    //    EInside A2a = Inside_accordion(A2);
    //std::cout << "A2: " << A2i << " " << A2a << std::endl;
    if(A2i == kSurface){
        //std::cout << "got A2" << std::endl;
        p = A2;
        return;
    }
 
    if(A1i != A2i){
        if(A2i == kOutside){
            std::swap(A1, A2);
            std::swap(A1i, A2i);
        }
        // here A1 is outside BP, A2 is inside BP
        G4ThreeVector d = (A2 - A1).unit();
        p = A1 + d * m_BoundingShape->DistanceToIn(A1, d);
        //std::cout << "got A1<->A2" << std::endl;
        return;
    }
    // here A1i == A2i
 
    G4double step;
    if(A1i == kInside){
        G4double d1 = m_BoundingShape->DistanceToOut(A1);
        G4double d2 = m_BoundingShape->DistanceToOut(A2);
        step = d1 > d2? d1 : d2;
        if(inner) step *= -2;
        else step *= 2;
    } else {
        G4double d1 = m_BoundingShape->DistanceToIn(A1);
        G4double d2 = m_BoundingShape->DistanceToIn(A2);
        step = d1 > d2? d1 : d2;
        if(inner) step *= 2;
        else step *= -2;
    }
 
    G4ThreeVector B1(0., r + step, z);
    B1[0] = GetCalculator()->AmplitudeOfSurface(B1, -1, p_fan);
    B1.rotateZ(dphi);
    EInside B1i = m_BoundingShape->Inside(B1);
    //    EInside B1a = Inside_accordion(B1);
    //std::cout << "B1: " << B1i << " " << B1a << std::endl;
    if(B1i == kSurface){
        //std::cout << "got B1" << std::endl;
        p = B1;
        return;
    }
    G4ThreeVector B2(0., r + step, z);
    B2[0] = GetCalculator()->AmplitudeOfSurface(B2, 1, p_fan);
    B2.rotateZ(dphi);
    EInside B2i = m_BoundingShape->Inside(B2);
    //    EInside B2a = Inside_accordion(B2);
    //std::cout << "B2: " << B2i << " " << B2a << std::endl;
    if(B2i == kSurface){
        //std::cout << "got B2" << std::endl;
        p = B2;
        return;
    }
 
    if(B1i == A1i || B2i == A1i){ // failed
        set_failover_point(p, "pol fail1");
        return;
    }
    if(A1i == kInside){
        std::swap(A1, B1);
        std::swap(A2, B2);
        std::swap(A1i, B1i);
        std::swap(A2i, B2i);
    }
    // here A* outside, B* inside, all on accordion surface
 
    G4ThreeVector d1 = (A1 - B1).unit();
    G4ThreeVector X1 = B1 + d1 * m_BoundingShape->DistanceToOut(B1, d1);
    G4ThreeVector d2 = (A2 - B2).unit();
    G4ThreeVector X2 = B2 + d2 * m_BoundingShape->DistanceToOut(B2, d2);
 
    G4ThreeVector X = X1;
    G4double phi1 = X1.phi(), phi2 = X2.phi();
    // X1 corresponds to side = -, X2 to side = +
    if(phi1 > 0. && phi2 < 0.) phi2 += CLHEP::twopi;
    G4double phiX = rnd->Uniform(phi1, phi2);
    if(phiX > CLHEP::pi) phiX -= CLHEP::twopi;
    X.setPhi(phiX);
 
    if(Inside(X) == kSurface){
        p = X;
    } else { // failed
        set_failover_point(p, "pol fail2");
    }
}

GetBoundingShape()

const G4VSolid * LArWheelSliceSolid::GetBoundingShape ( void ) const

inline

Definition at line 91 of file LArWheelSliceSolid.h.

{ return m_BoundingShape; }

GetCalculator()

const LArWheelCalculator * LArWheelSliceSolid::GetCalculator ( void ) const

inline

Definition at line 92 of file LArWheelSliceSolid.h.

{ return m_Calculator; }

GetCubicVolume()

G4double LArWheelSliceSolid::GetCubicVolume

(

void

)

Definition at line 316 of file LArWheelSliceSolidTests.cxx.

{
  // sagging ignored, effect should be negligible
    double result =
        m_f_vol->Integral(m_Rmin, m_Rmax, IntPrecision)
 
#ifndef LOCAL_DEBUG
        * GetCalculator()->GetNumberOfFans()
#endif
    ;
    return result;
}

GetEntityType()

G4GeometryType LArWheelSliceSolid::GetEntityType ( ) const

inline

Definition at line 78 of file LArWheelSliceSolid.h.

{ return TypeStr(); }

GetExtent()

G4VisExtent LArWheelSliceSolid::GetExtent

(

)

const

Definition at line 96 of file LArWheelSliceSolid.cxx.

{
    return m_BoundingShape->GetExtent();
}

GetPointOnSurface()

G4ThreeVector LArWheelSliceSolid::GetPointOnSurface

(

void

)

const

Definition at line 69 of file LArWheelSliceSolidTests.cxx.

{
    if(rnd == 0) rnd = new TRandom3(0);
    G4double r = rnd->Uniform();
    G4ThreeVector p(0., 0., 0.);
 
    G4double level1 = .980;
    G4double level2 = .993;
    const char *v = getenv("LARWHEELSLICESOLID_TEST_MODE_LEVEL1");
    if(v) level1 = atof(v);
    const char *v1 = getenv("LARWHEELSLICESOLID_TEST_MODE_LEVEL2");
    if(v1) level2 = atof(v1);
 
#if LOCAL_DEBUG > 1
    std::cout << "LWS::GPOS " << r << std::endl;
#endif
 
    if(r <= level1){
        get_point_on_accordion_surface(p);
    } else if(r <= level2){
        get_point_on_polycone_surface(p);
    } else if(r <= 1.){
        get_point_on_flat_surface(p);
    } else {
        G4Exception(
            "LArWheelSliceSolid", "Rnd generator error",
            FatalException, "GetPointOnSurface: Wrong data from rnd generator"
        );
    }
    return p;
}

GetSurfaceArea()

G4double LArWheelSliceSolid::GetSurfaceArea

(

void

)

Definition at line 367 of file LArWheelSliceSolidTests.cxx.

{
    double result = 0.;
 
    double a1 = get_area_on_polycone();
    result += a1;
#ifdef LOCAL_DEBUG
    std::cout << "get_area_on_polycone: " << a1/mm2 << std::endl;
#endif
 
    double a2 = get_area_on_face();
    result += a2;
#ifdef LOCAL_DEBUG
    std::cout << "get_area_on_face: " << a2/mm2 << std::endl;
#endif
 
    double a3 = get_area_on_side();
    result += a3;
#ifdef LOCAL_DEBUG
    std::cout << "get_area_on_side: " << a3/mm2 << std::endl;
#endif
 
  // sagging ignored, effect should be negligible
    return result
#ifndef LOCAL_DEBUG
        * GetCalculator()->GetNumberOfFans()
#endif
    ;
}

in_iteration_process()

G4double LArWheelSliceSolid::in_iteration_process ( const G4ThreeVector & p, G4double dist_p, G4ThreeVector & B, int p_fan ) const

private

Definition at line 177 of file LArWheelSliceSolidDisToIn.cxx.

{
    LWSDBG(6, std::cout << "iip from " << p << " to " << B
                        << " dir " << (B - p).unit()
                        << std::endl);
 
    G4ThreeVector A, C, diff;
    A = p;
    G4double dist_c;
    unsigned int niter = 0;
  //  assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(A)) > m_FHTplusT);
  //  assert(GetCalculator()->DistanceToTheNeutralFibre(A) == dist_p);
    do {
        C = A + B;
        C *= 0.5;
        dist_c = GetCalculator()->DistanceToTheNeutralFibre(C, p_fan);
        if(dist_c * dist_p < 0. || fabs(dist_c) < m_FHTminusT){
            B = C;
        } else {
            A = C;
        }
        niter ++;
        diff = A - B;
    } while(diff.mag2() > s_IterationPrecision2 && niter < s_IterationsLimit);
    assert(niter < s_IterationsLimit);
    assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(B, p_fan)) < m_FHTplusT);
    diff = p - B;
    LWSDBG(7, std::cout << "iip result in " << niter << " = " << B
                        << " " << diff.mag() << std::endl);
    return diff.mag();
}

init_tests()

void LArWheelSliceSolid::init_tests ( void )

private

Definition at line 608 of file LArWheelSliceSolidTests.cxx.

{
  m_test_index = double(solid.size());
  solid[m_test_index] = this;
 
#ifdef DEBUG_LARWHEELSLICESOLID
    if(Verbose > 0)
    std::cout << "LArWheelSliceSolid::init_tests: put " << this
              << " with index " << m_test_index << std::endl;
#endif
 
  m_f_area = new TF1(
                   (GetName() + "_f_area").c_str(), &LArWheelSliceSolid_fcn_area,
                   m_Zmin, m_Zmax, 2
                   );
  m_f_area->FixParameter(1, m_test_index);
 
  m_f_vol = new TF1(
                  (GetName() + "_f_vol").c_str(), &LArWheelSliceSolid_fcn_vol,
                  m_Rmin, m_Rmax, 1
                  );
  m_f_vol->FixParameter(0, m_test_index);
 
  m_f_area_on_pc = new TF1(
                         (GetName() + "_f_area_pc").c_str(), &LArWheelSliceSolid_fcn_area_on_pc,
                         m_Zmin, m_Zmax, 1
                         );
  m_f_area_on_pc->FixParameter(0, m_test_index);
 
  m_f_length = new TF1(
                     (GetName() + "_f_length").c_str(), &fcn_length,
                     m_Zmin, m_Zmax, 2
                     );
  m_f_length->FixParameter(1, m_test_index);
 
  m_f_side_area = new TF1(
                        (GetName() + "_f_side_area").c_str(), &LArWheelSliceSolid_fcn_side_area,
                        m_Rmin, m_Rmax, 1
                        );
  m_f_side_area->FixParameter(0, m_test_index);
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

inner_solid_init()

void LArWheelSliceSolid::inner_solid_init ( const G4String & bs_name, size_t slice )

private

Definition at line 193 of file LArWheelSliceSolidInit.cxx.

{
    std::array<G4double,2> zPlane{}, rInner{}, rOuter{};
    zPlane[1] = GetCalculator()->GetWheelThickness();
    GetCalculator()->GetWheelInnerRadius(rInner);
    GetCalculator()->GetWheelOuterRadius(rOuter);
 
    std::vector<G4double> zsect;
    fill_zsect(zsect);
    check_slice(zsect.size(), slice);
 
    m_Zmin = zsect[slice]; m_Zmax = zsect[slice + 1];
    m_Rmin = rInner[0];      m_Rmax = rOuter[1];
    const G4double ainn = (rInner[1] - rInner[0]) / (zPlane[1] - zPlane[0]);
    const G4double aout = (rOuter[1] - rOuter[0]) / (zPlane[1] - zPlane[0]);
    const G4double R1inn = ainn * (m_Zmin - zPlane[0]) + rInner[0];
    const G4double R1out = aout * (m_Zmin - zPlane[0]) + rOuter[0];
    const G4double R2inn = ainn * (m_Zmax - zPlane[0]) + rInner[0];
    const G4double R2out = aout * (m_Zmax - zPlane[0]) + rOuter[0];
 
    m_BoundingShape = new G4ShiftedCone(
        bs_name + "Cone", m_Zmin, m_Zmax, R1inn, R1out, R2inn, R2out
    );
 
    const G4double FanPhiAmplitude = 0.065; // internal technical constant, should not go in DB
    const G4double phi_min = CLHEP::halfpi
                           - FanPhiAmplitude
                           - GetCalculator()->GetFanStepOnPhi() * 2;
    m_Xmax = rOuter[1]*cos(phi_min);
    m_Xmin = -m_Xmax;
 
    m_Ymin = m_Rmin * 0.9;
}

Inside()

EInside LArWheelSliceSolid::Inside

(

const G4ThreeVector &

inputP

)

const

Definition at line 15 of file LArWheelSliceSolid.cxx.

{
    LWSDBG(10, std::cout << std::setprecision(25));
    LWSDBG(1, std::cout << TypeStr() << " Inside " << MSG_VECTOR(inputP) << std::endl);
    const EInside inside_BS = m_BoundingShape->Inside(inputP);
    if(inside_BS == kOutside){
        LWSDBG(2, std::cout << "outside BS" << std::endl);
        return kOutside;
    }
    G4ThreeVector p(inputP);
    int p_fan = 0;
    const G4double d = fabs(GetCalculator()->DistanceToTheNearestFan(p, p_fan));
    if(d > m_FHTplusT){
        LWSDBG(2, std::cout << "outside fan d=" << d << ", m_FHTplusT=" << m_FHTplusT << std::endl);
        return kOutside;
    }
    if(d < m_FHTminusT){
        LWSDBG(2, std::cout << "inside fan d=" << d << ", m_FHTminusT=" << m_FHTminusT << ", inside_BS=" << inside(inside_BS) << std::endl);
        return inside_BS;
    }
    LWSDBG(2, std::cout << "surface" << std::endl);
    return kSurface;
}

Inside_accordion()

EInside LArWheelSliceSolid::Inside_accordion ( const G4ThreeVector & p ) const

private

Definition at line 29 of file LArWheelSliceSolidTests.cxx.

{
    G4ThreeVector p1 = p;
    int p1_fan = 0;
    G4double d = m_FanHalfThickness - fabs(GetCalculator()->DistanceToTheNearestFan(p1, p1_fan));
    if(d > s_Tolerance) return kInside;
    if(d > -s_Tolerance) return kSurface;
    return kOutside;
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

out_iteration_process()

G4double LArWheelSliceSolid::out_iteration_process ( const G4ThreeVector & p, G4ThreeVector & B, const int p_fan ) const

private

Definition at line 139 of file LArWheelSliceSolidDisToOut.cxx.

{
    LWSDBG(6, std::cout << "oip: " << p << " " << B);
    assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(p, p_fan)) < m_FHTplusT);
    assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(B, p_fan)) > m_FHTminusT);
    G4ThreeVector A(p), C, diff;
    unsigned int niter = 0;
    do {
        C = A + B;
        C *= 0.5;
        if(fabs(GetCalculator()->DistanceToTheNeutralFibre(C, p_fan)) < m_FHTplusT){
            A = C;
        } else {
            B = C;
        }
        niter ++;
        diff = A - B;
    } while(diff.mag2() > s_IterationPrecision2 && niter < s_IterationsLimit);
    assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(B, p_fan)) > m_FHTplusT);
    assert(niter < s_IterationsLimit);
    diff = p - B;
    LWSDBG(7, std::cout << " -> " << B << " " << diff.mag());
    LWSDBG(6, std::cout << std::endl);
    return diff.mag();
}

outer_solid_init()

void LArWheelSliceSolid::outer_solid_init ( const G4String & bs_name, size_t slice )

private

Definition at line 227 of file LArWheelSliceSolidInit.cxx.

{
    std::array<G4double,3> zPlane{}, rInner{}, rOuter{};
    zPlane[1] = GetCalculator()->GetWheelInnerRadius(rInner);
    zPlane[2] = GetCalculator()->GetWheelThickness();
    GetCalculator()->GetWheelOuterRadius(rOuter);
 
    std::vector<G4double> zsect;
    fill_zsect(zsect, zPlane[1]);
    check_slice(zsect.size(), slice);
 
    m_Zmin = zsect[slice]; m_Zmax = zsect[slice + 1];
    m_Rmin = rInner[0];      m_Rmax = rOuter[1];
    const size_t i = m_Zmax > zPlane[1]? 1: 0;
    const G4double dz = zPlane[i + 1] - zPlane[i];
    const G4double ainn = (rInner[i + 1] - rInner[i]) / dz;
    const G4double aout = (rOuter[i + 1] - rOuter[i]) / dz;
    const G4double R1inn = ainn * (m_Zmin - zPlane[i]) + rInner[i];
    const G4double R1out = aout * (m_Zmin - zPlane[i]) + rOuter[i];
    const G4double R2inn = ainn * (m_Zmax - zPlane[i]) + rInner[i];
    const G4double R2out = aout * (m_Zmax - zPlane[i]) + rOuter[i];
 
    m_BoundingShape = new G4ShiftedCone(
        bs_name + "Cone", m_Zmin, m_Zmax, R1inn, R1out, R2inn, R2out
    );
 
    const G4double FanPhiAmplitude = 0.02; // internal technical constant, should not go in DB
    const G4double phi_min = CLHEP::halfpi
                           - FanPhiAmplitude
                           - GetCalculator()->GetFanStepOnPhi() * 2;
    m_Xmax = rOuter[1]*cos(phi_min);
    m_Xmin = -m_Xmax;
 
    m_Ymin = m_Rmin * 0.9;
}

search_for_most_remoted_point()

G4bool LArWheelSliceSolid::search_for_most_remoted_point ( const G4ThreeVector & a, const G4ThreeVector & b, G4ThreeVector & C, const int p_fan ) const

private

Definition at line 169 of file LArWheelSliceSolidDisToOut.cxx.

{
    LWSDBG(6, std::cout << "sfmrp " << a << " " << b << std::endl);
    G4ThreeVector diff(b - a);
 
    if(diff.mag2() <= s_IterationPrecision2) return false;
    G4ThreeVector A(a), B(b), l(diff.unit() * s_IterationPrecision);
  // find the most remoted point on the line AB
  // and check if it is outside vertical fan
  // small vector along the segment AB
    G4double d1, d2;
    unsigned int niter = 0;
  // searching for maximum of (GetCalculator()->DistanceToTheNeutralFibre)^2 along AB
    do {
        C = A + B;
        C *= 0.5;
        d1 = GetCalculator()->DistanceToTheNeutralFibre(C, p_fan);
        if(fabs(d1) > m_FHTplusT){
      // here out_iteration_process gives the answer
            LWSDBG(7, std::cout << "sfmrp -> " << C << " " << fabs(d1)
                                << "  " << (C - a).unit() << " "
                                << (C - a).mag() << std::endl);
            return true;
        }
    // sign of derivative
    //d1 = GetCalculator()->DistanceToTheNeutralFibre(C + l);
        d2 = GetCalculator()->DistanceToTheNeutralFibre(C - l, p_fan);
        if(d1 * d1 - d2 * d2 > 0.) A = C;
        else B = C;
        niter ++;
        diff = A - B;
    } while(diff.mag2() > s_IterationPrecision2 && niter < s_IterationsLimit);
  // the line entirely lies inside fan
    assert(niter < s_IterationsLimit);
    return false;
}

search_for_nearest_point()

G4double LArWheelSliceSolid::search_for_nearest_point ( const G4ThreeVector & p_in, const G4double dist_p_in, const G4ThreeVector & p_out, int p_fan ) const

private

Definition at line 213 of file LArWheelSliceSolidDisToIn.cxx.

{
    LWSDBG(6, std::cout << "sfnp " << MSG_VECTOR(p_in) << " "
                        << MSG_VECTOR(p_out) << std::endl);
 
    G4ThreeVector A, B, C, l, diff;
    A = p_in;
    B = p_out;
    diff = B - A;
    l = diff.unit() * s_IterationPrecision;
  // this is to correctly take the sign of the distance into account
    G4double sign = dist_p_in < 0.? -1. : 1.;
    G4double d_prime;
    G4double dist_c;
    unsigned long niter = 0;
    do {
        C = A + B;
        C *= 0.5;
        dist_c = GetCalculator()->DistanceToTheNeutralFibre(C, p_fan);
        if(dist_c * sign <= 0.){ // we are in coditions for in_iteration_process
            LWSDBG(7, std::cout << "sfnp0 " << dist_c << std::endl);
            return in_iteration_process(p_in, dist_p_in, C, p_fan);
        }
    // calculate sign of derivative of distance to the neutral fibre
    // hope this substitution is acceptable
        diff = C - l;
        d_prime = (dist_c - GetCalculator()->DistanceToTheNeutralFibre(diff, p_fan)) * sign;
        if(d_prime < 0.) A = C;
        else B = C;
        niter ++;
        diff = A - B;
    } while(diff.mag2() > s_IterationPrecision2 && niter < s_IterationsLimit);
    assert(niter < s_IterationsLimit);
    if(fabs(dist_c) < m_FHTminusT){
        LWSDBG(7, std::cout << "sfnp1 " << dist_c << std::endl);
        return in_iteration_process(p_in, dist_p_in, C, p_fan);
    }
  //  let's check at p_in and p_out
    if(dist_p_in * sign < dist_c * sign){
        C = p_in;
        dist_c = dist_p_in;
    }
    G4double dist_p_out = GetCalculator()->DistanceToTheNeutralFibre(p_out, p_fan);
    if(dist_p_out *sign < dist_c * sign) C = p_out;
    if(fabs(dist_p_out) < m_FHTminusT){
        LWSDBG(7, std::cout << "sfnp2 " << dist_p_out << std::endl);
        return in_iteration_process(p_in, dist_p_in, C, p_fan);
    }
    return kInfinity;
}

set_failover_point()

void LArWheelSliceSolid::set_failover_point ( G4ThreeVector & p, const char * m = 0 ) const

private

Definition at line 39 of file LArWheelSliceSolidTests.cxx.

  {
    p[0] = 0.; p[1] = m_Rmin;
    if(m_Zmin < s_Tolerance) p[2] = 0.;
    else if(m_Calculator->GetWheelThickness() - m_Zmax < s_Tolerance) p[2] = m_Zmax;
    else p[2] = (m_Zmin + m_Zmax) * 0.5;
    int p_fan = 0;
    GetCalculator()->DistanceToTheNearestFan(p, p_fan);
 
#ifdef LOCAL_DEBUG
    if(m) std::cout << m << std::endl;
#endif
  }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

StreamInfo()

virtual std::ostream & LArWheelSliceSolid::StreamInfo ( std::ostream & os ) const

inlinevirtual

Definition at line 82 of file LArWheelSliceSolid.h.

{ return os; }

SurfaceNormal()

G4ThreeVector LArWheelSliceSolid::SurfaceNormal

(

const G4ThreeVector &

inputP

)

const

Definition at line 39 of file LArWheelSliceSolid.cxx.

{
    LWSDBG(1, std::cout << TypeStr() << " SurfaceNormal" << MSG_VECTOR(inputP) << std::endl);
    EInside inside_BS = m_BoundingShape->Inside(inputP);
    if(inside_BS != kInside){
        LWSDBG(2, std::cout << "not inside BS" << std::endl);
        return m_BoundingShape->SurfaceNormal(inputP);
    }
    G4ThreeVector p( inputP );
    int p_fan = 0;
    GetCalculator()->DistanceToTheNearestFan(p, p_fan);
    G4ThreeVector d = GetCalculator()->NearestPointOnNeutralFibre(p, p_fan);
    d.rotateZ(inputP.phi() -  p.phi()); // rotate back to initial position
    LWSDBG(4, std::cout << "npnf" << MSG_VECTOR(d) << std::endl);
    p = inputP - d;
    LWSDBG(2, std::cout << "sn " << MSG_VECTOR(p.unit()) << std::endl);
    return(p.unit());
}

test()

void LArWheelSliceSolid::test ( void )

private

Definition at line 397 of file LArWheelSliceSolidTests.cxx.

{
  boost::io::ios_all_saver ias(std::cout);
  const char *on = getenv("LARWHEELSLICESOLID_TEST");
  if(on == 0) return;
  std::string test_mode = on;
 
  std::cout << "============| LArWheelSliceSolid test() routine |=============="
            << std::endl;
  std::cout << "Solid of type " << TypeStr() << std::endl;
  std::cout.precision(6);
  std::cout << std::fixed;
  const char *prec = getenv("LARWHEELSLICESOLID_TEST_INTPRECISION");
  if(prec) IntPrecision = atof(prec);
  std::cout << "Int. precision " << IntPrecision << std::endl;
  std::cout << "test mode " << test_mode << std::endl;
 
  std::cout << "m_Rmin = " << m_Rmin << " m_Rmax = " << m_Rmax << std::endl
            << "m_Zmin = " << m_Zmin << " m_Zmax = " << m_Zmax << std::endl;
 
  //    TFile *F = new TFile("LArWheelSliceSolid_test.root", "RECREATE");
  TFile *F = 0;
  TNtupleD *T = 0;
  if(test_mode.find("root") != std::string::npos){
    F = new TFile("LArWheelSliceSolid_test.root", "UPDATE");
    T = new TNtupleD(GetName(), GetName(), "x:y:z");
  }
  int N = 1000000;
  const int Nmax(1000000000);
  char *NN = getenv("LARWHEELSLICESOLID_TEST_NPOINTS");
 
  if(NN) {
    char *endptr;
    N = strtol(NN, &endptr, 0);
    if (endptr[0] != '\0') {
      throw std::invalid_argument("Could not convert string to int: " + std::string(NN));
    }
  }
  if (Nmax<N) {
    std::cout << "Number of points from LARWHEELSLICESOLID_TEST_NPOINTS environment variable ("<<N<<") is too large. Using " << Nmax << " instead." << std::endl;
    N=Nmax;
  }
  if (N<0) {
    std::cout << "Number of points from LARWHEELSLICESOLID_TEST_NPOINTS environment variable ("<<N<<") is negative!!. Using 0 instead." << std::endl;
    N=0;
  }
  if(test_mode.find("points") == std::string::npos){
    N = 0;
  } else {
    std::cout << N << " points" << std::endl;
  }
  for(int i = 0; i < N; ++ i){
    G4ThreeVector p = GetPointOnSurface();
#ifdef LOCAL_DEBUG
    EInside ii = Inside(p);
    if(ii != kSurface){
      std::cout << i << " "
                << (ii == kInside? "inside": "outside")
                << std::endl;
    }
#endif
    if(T) T->Fill(p[0], p[1], p[2]);
  }
  if(F){
    T->Write();
    F->Write();
    F->Close();
    delete F;
  }
 
  if(test_mode.find("volume") != std::string::npos){
    double cv = GetCubicVolume();
    std::cout << "GetCubicVolume: " << cv/CLHEP::mm3 << " mm^3" << std::endl;
  }
 
  if(test_mode.find("area") != std::string::npos){
    double sa = GetSurfaceArea();
    std::cout << "GetSurfaceArea: " << sa/CLHEP::mm2 << " mm^2" << std::endl;
  }
 
  std::cout << "======= end of ArWheelSolid test() routine ============="
            << std::endl;
 
    if(test_mode.find("once") != std::string::npos) exit(0);
    ias.restore();
}

TypeStr()

G4String LArWheelSliceSolid::TypeStr ( void ) const

private

Definition at line 67 of file LArWheelSliceSolid.cxx.

{
    G4String ret("");
    switch(m_Pos){
    case Inner:
        switch(m_Type){
        case Absorber: ret = "LArInnerAbsorberWheel"; break;
        case Electrode: ret = "LArInnerElectrodWheel"; break;
        case Glue: ret = "LArInnerGlueWheel"; break;
        case Lead: ret = "LArInnerLeadWheel"; break;
        }
        break;
    case Outer:
        switch(m_Type){
        case Absorber: ret = "LArOuterAbsorberWheel"; break;
        case Electrode: ret = "LArOuterElectrodWheel"; break;
        case Glue: ret = "LArOuterGlueWheel"; break;
        case Lead: ret = "LArOuterLeadWheel"; break;
        }
        break;
    }
    return ret;
}

Friends And Related Symbol Documentation

LArWheelSliceSolid_fcn_area

double LArWheelSliceSolid_fcn_area ( double * x, double * p )

friend

Definition at line 528 of file LArWheelSliceSolidTests.cxx.

{
  const double &z = x[0];
  const double &r = p[0];
  const double &index = p[1];
 
  G4ThreeVector a(0., r, z);
  double b = solid[index]->GetCalculator()->AmplitudeOfSurface(a, -1, 121) // sagging ignored, effect should be negligible, use arbitrary fan number
    - solid[index]->GetCalculator()->AmplitudeOfSurface(a, 1, 121);
  return b;
}

LArWheelSliceSolid_fcn_area_on_pc

double LArWheelSliceSolid_fcn_area_on_pc ( double * x, double * p )

friend

Definition at line 548 of file LArWheelSliceSolidTests.cxx.

{
  const double &z = x[0];
  const double &index = p[0];
 
  G4double rmin, rmax;
  get_r(solid[index]->m_BoundingShape, z, rmin, rmax);
 
  double result = 0.;
  G4ThreeVector a(0., rmin, z);
  result += solid[index]->GetCalculator()->AmplitudeOfSurface(a, -1, 232) // sagging ignored, effect should be negligible, use arbitrary fan number
    - solid[index]->GetCalculator()->AmplitudeOfSurface(a, 1, 232);
  a[1] = rmax;
  result += solid[index]->GetCalculator()->AmplitudeOfSurface(a, -1, 343)
    - solid[index]->GetCalculator()->AmplitudeOfSurface(a, 1, 343);
 
  return result;
}

LArWheelSliceSolid_fcn_side_area

double LArWheelSliceSolid_fcn_side_area ( double * x, double * p )

friend

Definition at line 600 of file LArWheelSliceSolidTests.cxx.

{
  const double &r = x[0];
  const double &index = p[0];
 
  return solid[index]->get_length_at_r(r);
}

LArWheelSliceSolid_fcn_vol

double LArWheelSliceSolid_fcn_vol ( double * x, double * p )

friend

Definition at line 540 of file LArWheelSliceSolidTests.cxx.

{
  const double &r = x[0];
  const double &index = p[0];
 
  return solid[index]->get_area_at_r(r);
}

LArWheelSliceSolid_get_dl

double LArWheelSliceSolid_get_dl ( double * x, double * par, G4int side )

friend

Definition at line 568 of file LArWheelSliceSolidTests.cxx.

{
  const double &z = x[0];
  const double &r = par[0];
  const double &index = par[1];
 
  const double h = 0.001;
 
  //check what happens if z+h > m_Zmax etc
  G4ThreeVector p(0., r, z + h);
  G4double D1 = solid[index]->GetCalculator()->AmplitudeOfSurface(p, side, 5665);  // sagging ignored, effect should be negligible, use arbitrary fan number
  p[2] = z - h;
  D1 -= solid[index]->GetCalculator()->AmplitudeOfSurface(p, side, 5665);
  D1 /= 2 * h;
 
  p[2] = z + h / 2;
  G4double D2 = solid[index]->GetCalculator()->AmplitudeOfSurface(p, side, 5665);
  p[2] = z - h / 2;
  D2 -= solid[index]->GetCalculator()->AmplitudeOfSurface(p, side, 5665);
  D2 /= h;
 
  G4double D = (D2 * 4 - D1) / 3.;
  G4double dl = sqrt(1 + D * D);
 
  return dl;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_BoundingShape

G4VSolid* LArWheelSliceSolid::m_BoundingShape {}

private

Definition at line 104 of file LArWheelSliceSolid.h.

{};

m_Calculator

const LArWheelCalculator* LArWheelSliceSolid::m_Calculator {}

private

Definition at line 103 of file LArWheelSliceSolid.h.

{};

m_f_area

TF1* LArWheelSliceSolid::m_f_area

protected

Definition at line 158 of file LArWheelSliceSolid.h.

m_f_area_on_pc

TF1 * LArWheelSliceSolid::m_f_area_on_pc

protected

Definition at line 158 of file LArWheelSliceSolid.h.

m_f_length

TF1 * LArWheelSliceSolid::m_f_length

protected

Definition at line 158 of file LArWheelSliceSolid.h.

m_f_side_area

TF1 * LArWheelSliceSolid::m_f_side_area

protected

Definition at line 158 of file LArWheelSliceSolid.h.

m_f_vol

TF1 * LArWheelSliceSolid::m_f_vol

protected

Definition at line 158 of file LArWheelSliceSolid.h.

m_FanHalfThickness

G4double LArWheelSliceSolid::m_FanHalfThickness {}

private

Definition at line 106 of file LArWheelSliceSolid.h.

{}, m_FHTplusT{}, m_FHTminusT{};

m_FHTminusT

G4double LArWheelSliceSolid::m_FHTminusT {}

private

Definition at line 106 of file LArWheelSliceSolid.h.

{}, m_FHTplusT{}, m_FHTminusT{};

m_FHTplusT

G4double LArWheelSliceSolid::m_FHTplusT {}

private

Definition at line 106 of file LArWheelSliceSolid.h.

{}, m_FHTplusT{}, m_FHTminusT{};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_Pos

pos_t LArWheelSliceSolid::m_Pos {}

private

Definition at line 101 of file LArWheelSliceSolid.h.

{};

m_Rmax

G4double LArWheelSliceSolid::m_Rmax {}

private

Definition at line 115 of file LArWheelSliceSolid.h.

{}, m_Zmax{}, m_Rmin{}, m_Rmax{};

m_Rmin

G4double LArWheelSliceSolid::m_Rmin {}

private

Definition at line 115 of file LArWheelSliceSolid.h.

{}, m_Zmax{}, m_Rmin{}, m_Rmax{};

m_test_index

double LArWheelSliceSolid::m_test_index

protected

Definition at line 161 of file LArWheelSliceSolid.h.

m_Type

type_t LArWheelSliceSolid::m_Type {}

private

Definition at line 102 of file LArWheelSliceSolid.h.

{};

m_Xmax

G4double LArWheelSliceSolid::m_Xmax {}

private

Definition at line 109 of file LArWheelSliceSolid.h.

{}, m_Xmax{};

m_Xmin

G4double LArWheelSliceSolid::m_Xmin {}

private

Definition at line 109 of file LArWheelSliceSolid.h.

{}, m_Xmax{};

m_Ymin

G4double LArWheelSliceSolid::m_Ymin {}

private

Definition at line 112 of file LArWheelSliceSolid.h.

{};

m_Zmax

G4double LArWheelSliceSolid::m_Zmax {}

private

Definition at line 115 of file LArWheelSliceSolid.h.

{}, m_Zmax{}, m_Rmin{}, m_Rmax{};

m_Zmin

G4double LArWheelSliceSolid::m_Zmin {}

private

Definition at line 115 of file LArWheelSliceSolid.h.

{}, m_Zmax{}, m_Rmin{}, m_Rmax{};

s_AngularTolerance

const G4double LArWheelSliceSolid::s_AngularTolerance = G4GeometryTolerance::GetInstance()->GetAngularTolerance() / 2

staticprivate

Definition at line 96 of file LArWheelSliceSolid.h.

s_IterationPrecision

const G4double LArWheelSliceSolid::s_IterationPrecision = 0.001*CLHEP::mm

staticprivate

Definition at line 97 of file LArWheelSliceSolid.h.

s_IterationPrecision2

const G4double LArWheelSliceSolid::s_IterationPrecision2 = s_IterationPrecision * s_IterationPrecision

staticprivate

Definition at line 98 of file LArWheelSliceSolid.h.

s_IterationsLimit

const unsigned int LArWheelSliceSolid::s_IterationsLimit = 50

staticprivate

Definition at line 99 of file LArWheelSliceSolid.h.

s_Tolerance

const G4double LArWheelSliceSolid::s_Tolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance() / 2

staticprivate

Definition at line 95 of file LArWheelSliceSolid.h.

---

The documentation for this class was generated from the following files:

• LArWheelSliceSolid.h
• LArWheelSliceSolid.cxx
• LArWheelSliceSolidDisToIn.cxx
• LArWheelSliceSolidDisToOut.cxx
• LArWheelSliceSolidInit.cxx
• LArWheelSliceSolidTests.cxx