WireCell::Gen::AnodePlane Class Reference

#include <AnodePlane.h>

Inheritance diagram for WireCell::Gen::AnodePlane:

Public Member Functions
	AnodePlane ()
virtual	~AnodePlane ()
virtual void	configure (const WireCell::Configuration &config)
	Accept a configuration. More...
virtual WireCell::Configuration	default_configuration () const
	Optional, override to return a hard-coded default configuration. More...
virtual int	ident () const
	IAnodePlane interface. More...
virtual int	nfaces () const
	Return number of faces (eg, MicroBooNE=1, DUNE=2) More...
virtual IAnodeFace::pointer	face (int ident) const
	Return a anode face by its ident number. More...
virtual IAnodeFace::vector	faces () const
	Return all faces. More...
virtual WirePlaneId	resolve (int channel) const
	Resolve a channel ident number to a WirePlaneId. More...
virtual std::vector< int >	channels () const
	Return a collection of all channels. More...
virtual IChannel::pointer	channel (int chident) const
	Return an IChannel with the associated channel ID. More...
virtual IWire::vector	wires (int channel) const
	Return all wires connected into the given channel ident number. More...
Public Member Functions inherited from WireCell::IAnodePlane
virtual	~IAnodePlane ()
Public Member Functions inherited from WireCell::IComponent< IAnodePlane >
virtual	~IComponent ()
Public Member Functions inherited from WireCell::Interface
virtual	~Interface ()
Public Member Functions inherited from WireCell::IConfigurable
virtual	~IConfigurable ()
Public Member Functions inherited from WireCell::IComponent< IConfigurable >
virtual	~IComponent ()

Private Attributes
int	m_ident
IAnodeFace::vector	m_faces
std::unordered_map< int, int >	m_c2wpid
std::unordered_map< int, IWire::vector >	m_c2wires
std::vector< int >	m_channels
std::unordered_map< int, IChannel::pointer >	m_ichannels
Log::logptr_t	l

Additional Inherited Members
Public Types inherited from WireCell::IComponent< IAnodePlane >
typedef std::shared_ptr< IAnodePlane >	pointer
	Access subclass facet by pointer. More...
typedef std::vector< pointer >	vector
	Vector of shared pointers. More...
Public Types inherited from WireCell::Interface
typedef std::shared_ptr< Interface >	pointer
Public Types inherited from WireCell::IComponent< IConfigurable >
typedef std::shared_ptr< IConfigurable >	pointer
	Access subclass facet by pointer. More...
typedef std::vector< pointer >	vector
	Vector of shared pointers. More...

Detailed Description

Definition at line 18 of file AnodePlane.h.

Constructor & Destructor Documentation

Gen::AnodePlane::AnodePlane

(

)

Definition at line 28 of file AnodePlane.cxx.

    : m_ident(0)
    , l(Log::logger("geom"))
{
}

virtual WireCell::Gen::AnodePlane::~AnodePlane ( )

inlinevirtual

Definition at line 22 of file AnodePlane.h.

{}

Member Function Documentation

IChannel::pointer Gen::AnodePlane::channel ( int  chident ) const

virtual

Return an IChannel with the associated channel ID.

Implements WireCell::IAnodePlane.

Definition at line 297 of file AnodePlane.cxx.

{
    auto it = m_ichannels.find(chident);
    if (it == m_ichannels.end()) {
        return nullptr;
    }
    return it->second;
}

std::vector< int > Gen::AnodePlane::channels ( ) const

virtual

Return a collection of all channels.

Implements WireCell::IAnodePlane.

Definition at line 306 of file AnodePlane.cxx.

{
    return m_channels;
}

void Gen::AnodePlane::configure ( const WireCell::Configuration &  config )

virtual

Accept a configuration.

Implements WireCell::IConfigurable.

Definition at line 108 of file AnodePlane.cxx.

{
    m_faces.clear();
    m_ident = get<int>(cfg, "ident", 0);

    // check for obsolete config params:
    if (!cfg["wires"].isNull()) {
        l->warn("AnodePlane configuration is obsolete.");
        l->warn("Use \"wire_store\" to name components instead of directly giving file names");
        l->warn("This job will likely throw an exception next");
    }

    // AnodePlane used to have the mistake of tight coupling with
    // field response functions.  
    if (!cfg["fields"].isNull() or !cfg["field_response"].isNull()) {
        l->warn("AnodePlane does not require any field response functions.");
    }

    auto jfaces = cfg["faces"];
    if (jfaces.isNull() or jfaces.empty() or (jfaces[0].isNull() and jfaces[1].isNull())) {
        l->critical("at least two faces need to be defined, got:\n{}", jfaces);
        THROW(ValueError() << errmsg{"AnodePlane: error in configuration"});        
    }


    const int nimpacts = get<int>(cfg, "nimpacts", default_nimpacts);


    // get wire schema
    const string ws_name = get<string>(cfg, "wire_schema");
    if (ws_name.empty()) {
        l->critical("\"wire_schema\" parameter must specify an IWireSchema component");
        THROW(ValueError() << errmsg{"\"wire_schema\" parameter must specify an IWireSchema component"});
    }
    auto iws = Factory::find_tn<IWireSchema>(ws_name); // throws if not found
    const WireSchema::Store& ws_store = iws->wire_schema_store();

    // keep track which channels we know about in this anode.
    m_channels.clear();

    const WireSchema::Anode& ws_anode = ws_store.anode(m_ident);

    std::vector<WireSchema::Face> ws_faces = ws_store.faces(ws_anode);
    const size_t nfaces = ws_faces.size();
    
    channel_wire_collector_t chwcollector;

    m_faces.resize(nfaces);
    // note, WireSchema requires front/back face ordering in an anode
    for (size_t iface=0; iface<nfaces; ++iface) { 
        const auto& ws_face = ws_faces[iface];
        std::vector<WireSchema::Plane> ws_planes = ws_store.planes(ws_face);
        const size_t nplanes = ws_planes.size();
        
        // location of imaginary boundary planes
        bool sensitive_face = true;
        auto jface = jfaces[(int)iface];
        if (jface.isNull()) {
            sensitive_face = false;
            l->debug("anode {} face {} is not sensitive", m_ident, iface);
        }
        const double response_x = jface["response"].asDouble();
        const double anode_x = get(jface, "anode", response_x);
        const double cathode_x = jface["cathode"].asDouble();
        l->debug("AnodePlane: X planes: \"cathode\"@ {}m, \"response\"@{}m, \"anode\"@{}m",
                cathode_x / units::m, response_x / units::m, anode_x/units::m);

        IWirePlane::vector planes(nplanes);
        // note, WireSchema requires U/V/W plane ordering in a face.
        for (size_t iplane=0; iplane<nplanes; ++iplane) { 
            const auto& ws_plane = ws_planes[iplane];

            WirePlaneId wire_plane_id(iplane2layer[iplane], iface, m_ident);
            if (wire_plane_id.index() < 0) {
                l->critical("Bad wire plane id: {}", wire_plane_id.ident());
                THROW(ValueError() << errmsg{format("bad wire plane id: %d", wire_plane_id.ident())});
            }

            // (wire,pitch) directions
            auto wire_pitch_dirs = ws_store.wire_pitch(ws_plane);
            auto ecks_dir = wire_pitch_dirs.first.cross(wire_pitch_dirs.second);

            std::vector<int> plane_chans = ws_store.channels(ws_plane);
            m_channels.insert(m_channels.end(), plane_chans.begin(), plane_chans.end());

            std::vector<WireSchema::Wire> ws_wires = ws_store.wires(ws_plane);
            const size_t nwires = ws_wires.size();
            IWire::vector wires(nwires);

            // note, WireSchema requires wire-in-plane ordering
            for (size_t iwire=0; iwire<nwires; ++iwire) {
                const auto& ws_wire = ws_wires[iwire];
                const int chanid = plane_chans[iwire];
                    
                Ray ray(ws_wire.tail, ws_wire.head);
                auto iwireptr = make_shared<SimpleWire>(wire_plane_id, ws_wire.ident,
                                                        iwire, chanid, ray,
                                                        ws_wire.segment);
                wires[iwire] = iwireptr;
                m_c2wires[chanid].push_back(iwireptr);
                m_c2wpid[chanid] = wire_plane_id.ident();
                chwcollector(iwireptr);
            } // wire

            const BoundingBox bb = ws_store.bounding_box(ws_plane);
            const Ray bb_ray = bb.bounds();
            const Vector plane_center = 0.5*(bb_ray.first + bb_ray.second);

            const double pitchmin = wire_pitch_dirs.second.dot(wires[0]->center() - plane_center);
            const double pitchmax = wire_pitch_dirs.second.dot(wires[nwires-1]->center() - plane_center);
            const Vector pimpos_origin(response_x, plane_center.y(), plane_center.z());

            l->debug("AnodePlane: face:{}, plane:{}, origin:{} mm",
                     iface, iplane, pimpos_origin/units::mm);

            Pimpos* pimpos = new Pimpos(nwires, pitchmin, pitchmax,
                                        wire_pitch_dirs.first, wire_pitch_dirs.second,
                                        pimpos_origin, nimpacts);

            IChannel::vector plane_channels;
            {
                for (auto w : wires) {
                    if (w->segment() > 0) {
                        continue;
                    }

                    const int chanid = w->channel();
                    SimpleChannel* sch = chwcollector(chanid);
                    sch->set_index(plane_channels.size());
                    IChannel::pointer ich(sch);
                    m_ichannels[chanid] = ich;
                    plane_channels.push_back(ich);
                }
            }
            sort(wires.begin(), wires.end(), IWireCompareIndex()); // redundant?
            planes[iplane] = make_shared<WirePlane>(ws_plane.ident, pimpos, wires, plane_channels);

            // Last iteration, use W plane to define volume
            if (iplane == nplanes-1) { 
                const double mean_pitch = (pitchmax - pitchmin) / (nwires-1);
                BoundingBox sensvol;
                if (sensitive_face) {
                    auto v1 = bb_ray.first;
                    auto v2 = bb_ray.second;
                    // Enlarge to anode/cathode planes in X and by 1/2 pitch in Z.
                    Point p1(  anode_x, v1.y(), std::min(v1.z(), v2.z()) - 0.5*mean_pitch);
                    sensvol(p1);
                    Point p2(cathode_x, v2.y(), std::max(v1.z(), v2.z()) + 0.5*mean_pitch);
                    sensvol(p2);
                }
                
                l->debug("AnodePlane: face:{} with {} planes and sensvol: {}",
                         ws_face.ident, planes.size(), sensvol.bounds());

                m_faces[iface] = make_shared<AnodeFace>(ws_face.ident, planes, sensvol);
            }
        } // plane
    } // face

    // remove any duplicate channels
    std::sort(m_channels.begin(), m_channels.end());
    auto chend = std::unique(m_channels.begin(), m_channels.end());
    m_channels.resize( std::distance(m_channels.begin(), chend) );

}

WireCell::Configuration Gen::AnodePlane::default_configuration ( ) const

virtual

Optional, override to return a hard-coded default configuration.

This number is used to take from the wire file the anode

Name of a IWireSchema component.

Reimplemented from WireCell::IConfigurable.

Definition at line 38 of file AnodePlane.cxx.

{
    Configuration cfg;

    /// This number is used to take from the wire file the anode
    put(cfg, "ident", 0);

    /// Name of a IWireSchema component.
    // note: this used to be a "wires" parameter directly specifying a filename.
    put(cfg, "wire_schema", "");

    // Number of impact positions per wire pitch.  This should likely
    // match exactly what the field response functions use.
    put(cfg, "nimpacts", default_nimpacts);

    // The AnodePlane has to two faces, one of which may be "null".
    // Face 0 or "front" is the one that is toward the positive X-axis
    // (wire coordinate system).  A face consists of wires and some
    // bounds on the X-coordinate in the form of three planes:
    //
    // - response :: The response plane demarks the location where the
    // complex fields near the wires are considered sufficiently
    // regular.
    //
    // - anode and cathode :: These two planes bracket the region in X
    // - for the volume associated with the face.  The transverse
    // - range is determined by the wires.  If anode is not given then
    // - response will be used instead.  Along with wires, these
    // - determine the sensitive bounding box of the AnodeFaces.
    //
    // eg: faces: [
    //       {response: 10*wc.cm - 6*wc.mm, 2.5604*wc.m},
    //       null,
    //     ]

    cfg["faces"][0] = Json::nullValue;
    cfg["faces"][1] = Json::nullValue;

    return cfg;
}

IAnodeFace::pointer Gen::AnodePlane::face ( int  ident ) const

virtual

Return a anode face by its ident number.

Implements WireCell::IAnodePlane.

Definition at line 275 of file AnodePlane.cxx.

{
    for (auto ptr : m_faces) {
        if (ptr->ident() == ident) {
            return ptr;
        }
    }
    return nullptr;
}

virtual IAnodeFace::vector WireCell::Gen::AnodePlane::faces ( ) const

inlinevirtual

Return all faces.

Implements WireCell::IAnodePlane.

Definition at line 34 of file AnodePlane.h.

{ return m_faces; }

virtual int WireCell::Gen::AnodePlane::ident ( ) const

inlinevirtual

IAnodePlane interface.

Implements WireCell::IAnodePlane.

Definition at line 31 of file AnodePlane.h.

{ return m_ident; }

virtual int WireCell::Gen::AnodePlane::nfaces ( ) const

inlinevirtual

Return number of faces (eg, MicroBooNE=1, DUNE=2)

Implements WireCell::IAnodePlane.

Definition at line 32 of file AnodePlane.h.

{ return m_faces.size(); }

WirePlaneId Gen::AnodePlane::resolve ( int  channel ) const

virtual

Resolve a channel ident number to a WirePlaneId.

Implements WireCell::IAnodePlane.

Definition at line 286 of file AnodePlane.cxx.

{
    const WirePlaneId bogus(0xFFFFFFFF);

    auto got = m_c2wpid.find(channel);
    if (got == m_c2wpid.end()) {
        return bogus;
    }
    return WirePlaneId(got->second);
}

IWire::vector Gen::AnodePlane::wires ( int  chident ) const

virtual

Return all wires connected into the given channel ident number.

Implements WireCell::IAnodePlane.

Definition at line 311 of file AnodePlane.cxx.

{
    auto it = m_c2wires.find(channel);
    if (it == m_c2wires.end()) {
        return IWire::vector();
    }
    return it->second;
}

Member Data Documentation

Log::logptr_t WireCell::Gen::AnodePlane::l

private

Definition at line 49 of file AnodePlane.h.

std::unordered_map<int, IWire::vector> WireCell::Gen::AnodePlane::m_c2wires

private

Definition at line 46 of file AnodePlane.h.

std::unordered_map<int, int> WireCell::Gen::AnodePlane::m_c2wpid

private

Definition at line 45 of file AnodePlane.h.

std::vector<int> WireCell::Gen::AnodePlane::m_channels

private

Definition at line 47 of file AnodePlane.h.

IAnodeFace::vector WireCell::Gen::AnodePlane::m_faces

private

Definition at line 43 of file AnodePlane.h.

std::unordered_map<int, IChannel::pointer> WireCell::Gen::AnodePlane::m_ichannels

private

Definition at line 48 of file AnodePlane.h.

int WireCell::Gen::AnodePlane::m_ident

private

Definition at line 42 of file AnodePlane.h.

---

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

• wire-cell-build/gen/inc/WireCellGen/AnodePlane.h
• wire-cell-build/gen/src/AnodePlane.cxx