WireCellToolkit
Wire Cell Simulation, Signal Process and Reconstruction Toolki for Liquid Argon Detectors
|
Namespaces | |
Array | |
Bits | |
Factory | |
Singleton interface. | |
FrameTools | |
Gen | |
Log | |
Persist | |
RayGrid | |
Response | |
Ress | |
SigProc | |
Sio | |
String | |
tagrules | |
Testing | |
units | |
Waveform | |
WireSchema | |
Typedefs | |
typedef Json::Value | Configuration |
typedef boost::error_info< struct tag_errmsg, std::string > | errmsg |
typedef D3Vector< double > | Point |
A 3D Cartesian point in double precision. More... | |
typedef Point | Vector |
An alias for Point. More... | |
typedef std::pair< Point, Point > | Ray |
A line segment running from a first (tail) to a second (head) point. More... | |
typedef std::pair< Ray, Ray > | ray_pair_t |
typedef std::vector< ray_pair_t > | ray_pair_vector_t |
typedef std::vector< Point > | PointVector |
PointVector - a collection of Points. More... | |
typedef std::pair< double, Vector > | ScalarPoint |
A scalar + vector, eg charge at a point. More... | |
typedef std::vector< ScalarPoint > | ScalarField |
typedef std::pair< Point, float > | PointValue |
PointValue - an association of a point and a value. More... | |
typedef std::vector< PointValue > | PointValueVector |
PointValueVector - a collection of point-value associations. More... | |
typedef std::set< Point, ComparePoints > | PointSet |
typedef D3Vector< float > | PointF |
typedef std::variant< size_t, IChannel::pointer, IWire::pointer, IBlob::pointer, ISlice::pointer, IChannel::shared_vector > | cluster_ptr_t |
The vertex property. More... | |
typedef boost::adjacency_list< boost::setS, boost::vecS, boost::undirectedS, cluster_node_t > | cluster_graph_t |
typedef boost::graph_traits< cluster_graph_t >::vertex_descriptor | cluster_vertex_t |
typedef boost::graph_traits< cluster_graph_t >::edge_descriptor | cluster_edge_t |
typedef boost::graph_traits< cluster_graph_t >::vertex_iterator | cluster_vertex_iter_t |
typedef IndexedGraph< cluster_node_t > | cluster_indexed_graph_t |
typedef std::set< IDepo::pointer, IDepoDriftCompare > | DepoTauSortedSet |
typedef std::set< IDiffusion::pointer, IDiffusionCompareLbegin > | IDiffusionSet |
typedef std::pair< IImpactResponse::pointer, IImpactResponse::pointer > | TwoImpactResponses |
typedef std::pair< IWire::pointer, IWire::pointer > | IWirePair |
Some common collections. More... | |
typedef std::set< IWire::pointer, IWireCompareIdent > | IWireSet |
typedef std::set< IWire::pointer, IWireCompareIndex > | IWireIndexSet |
typedef std::set< IWire::pointer, IWireCompareSegment > | IWireSegmentSet |
typedef boost::function< bool(IWire::pointer)> | wire_selector |
typedef std::queue< boost::any > | Pipe |
typedef std::vector< Proc * > | Pipeline |
typedef std::deque< boost::any > | queuedany |
Enumerations | |
enum | WirePlaneLayer_t { kUnknownLayer =0, kUlayer =1, kVlayer =2, kWlayer =4 } |
Enumerate layer IDs. These are not indices! More... | |
Functions | |
std::ostream & | operator<< (std::ostream &os, const WireCell::Binning &bins) |
template<typename T > | |
T | convert (const Configuration &cfg, const T &def=T()) |
Convert a configuration value to a particular type. More... | |
template<> | |
bool | convert< bool > (const Configuration &cfg, const bool &def) |
template<> | |
int | convert< int > (const Configuration &cfg, const int &def) |
template<> | |
float | convert< float > (const Configuration &cfg, const float &def) |
template<> | |
double | convert< double > (const Configuration &cfg, const double &def) |
template<> | |
std::string | convert< std::string > (const Configuration &cfg, const std::string &def) |
template<> | |
std::vector< std::string > | convert< std::vector< std::string > > (const Configuration &cfg, const std::vector< std::string > &def) |
template<> | |
std::vector< int > | convert< std::vector< int > > (const Configuration &cfg, const std::vector< int > &def) |
template<> | |
std::vector< double > | convert< std::vector< double > > (const Configuration &cfg, const std::vector< double > &def) |
Configuration | branch (Configuration cfg, const std::string &dotpath) |
Follow a dot.separated.path and return the branch there. More... | |
Configuration | update (Configuration &a, Configuration &b) |
Merge dictionary b into a, return a. More... | |
Configuration | append (Configuration &a, Configuration &b) |
Return an array which is composed of the array b appended to the array a. More... | |
template<typename T > | |
Configuration | find (Configuration &lst, const std::string &dotpath, const T &val) |
Return dictionary in given list if it value at dotpath matches. More... | |
template<typename T > | |
T | get (Configuration cfg, const std::string &dotpath, const T &def=T()) |
Get value in configuration at the dotted path from or return default. More... | |
template<typename T > | |
void | put (Configuration &cfg, const std::string &dotpath, const T &val) |
Put value in configuration at the dotted path. More... | |
template<class T > | |
std::ostream & | operator<< (std::ostream &os, const D3Vector< T > &vec) |
template<class T > | |
D3Vector< T > | operator- (const D3Vector< T > a, const D3Vector< T > b) |
template<class T > | |
D3Vector< T > | operator+ (const D3Vector< T > a, const D3Vector< T > b) |
template<class T > | |
D3Vector< T > | operator* (const D3Vector< T > a, T s) |
template<class T > | |
D3Vector< T > | operator/ (const D3Vector< T > a, T s) |
template<class T > | |
bool | operator== (const D3Vector< T > &a, const D3Vector< T > &b) |
template<class T > | |
bool | operator!= (const D3Vector< T > &a, const D3Vector< T > &b) |
template<class T > | |
D3Vector< T > | operator* (T s, const D3Vector< T > a) |
std::size_t | fft_best_length (size_t nsamples, bool keep_odd_even=false) |
int | hit_square (int axis0, const Ray &bounds, const Point &point, const Vector &dir, Ray &hits) |
int | box_intersection (const Ray &bounds, const Ray &ray, Ray &hits) |
double | memusage_resident () |
double | memusage_shared () |
double | memusage_size () |
bool | point_contained (const Point &point, const Ray &bounds) |
bool | point_contained (const Point &point, const Ray &bounds, int axis) |
double | point_angle (const Vector &axis, const Vector &vector) |
Ray | ray_pitch (const Ray &ray1, const Ray &ray2) |
double | ray_length (const Ray &ray) |
Vector | ray_vector (const Ray &ray) |
Vector | ray_unit (const Ray &ray) |
double | ray_dist (const Ray &ray, const Point &point) |
double | ray_volume (const Ray &ray) |
template<> | |
WireCell::Point | convert< WireCell::Point > (const Configuration &cfg, const WireCell::Point &def) |
template<> | |
WireCell::Ray | convert< WireCell::Ray > (const Configuration &cfg, const WireCell::Ray &def) |
std::ostream & | operator<< (std::ostream &os, const WireCell::Ray &ray) |
WireCell::Ray | operator/ (WireCell::Ray ray, const double &scale) |
std::ostream & | operator<< (std::ostream &os, const WireCell::Quantity &q) |
WireCell::Quantity | operator- (const WireCell::Quantity &other) |
WireCell::Quantity | operator* (const WireCell::Quantity &lhs, const WireCell::Quantity &rhs) |
WireCell::Quantity | operator/ (const WireCell::Quantity &lhs, const WireCell::Quantity &rhs) |
WireCell::Quantity | operator+ (const WireCell::Quantity &lhs, const WireCell::Quantity &rhs) |
WireCell::Quantity | operator- (const WireCell::Quantity &lhs, const WireCell::Quantity &rhs) |
bool | operator== (const WireCell::Quantity &lhs, const double &scalar) |
bool | operator!= (const WireCell::Quantity &lhs, const double &scalar) |
bool | operator< (const WireCell::Quantity &lhs, const double &scalar) |
bool | operator> (const WireCell::Quantity &lhs, const double &scalar) |
bool | operator== (const double &scalar, const WireCell::Quantity &rhs) |
bool | operator!= (const double &scalar, const WireCell::Quantity &rhs) |
bool | operator< (const double &scalar, const WireCell::Quantity &rhs) |
bool | operator> (const double &scalar, const WireCell::Quantity &rhs) |
template<> | |
tagrules::tagset_t | convert< tagrules::tagset_t > (const Configuration &cfg, const tagrules::tagset_t &def) |
template<> | |
tagrules::ruleset_t | convert< tagrules::ruleset_t > (const Configuration &cfg, const tagrules::ruleset_t &def) |
std::string | demangle (const std::string &name) |
template<class T > | |
std::string | type (const T &t) |
template<typename Type > | |
std::vector< Type > | oftype (const cluster_indexed_graph_t &g) |
template<typename Type > | |
std::vector< Type > | neighbors_oftype (const cluster_indexed_graph_t &g, const cluster_node_t &n) |
IDepo::vector | depo_chain (IDepo::pointer recent) |
bool | ascending_time (const WireCell::IDepo::pointer &lhs, const WireCell::IDepo::pointer &rhs) |
Compare two IDepo::pointer by time (ascending). x is used to break tie. More... | |
bool | descending_time (const WireCell::IDepo::pointer &lhs, const WireCell::IDepo::pointer &rhs) |
Compare two IDepo::pointers for by time, descending. x is used to break tie. More... | |
bool | ascending_index (IWire::pointer lhs, IWire::pointer rhs) |
std::ostream & | operator<< (std::ostream &os, const WireCell::WirePlaneId &wpid) |
std::ostream & | operator<< (std::ostream &o, const WireCell::WirePlaneLayer_t &layer) |
template<> | |
WireCell::WirePlaneId | convert< WireCell::WirePlaneId > (const Configuration &cfg, const WireCell::WirePlaneId &def) |
Proc * | join (Pipeline &pipeline, Proc *src, Proc *dst) |
Variables | |
wire_selector | select_all_wires = WirePlaneSelector(kUlayer|kVlayer|kWlayer, 0, 0) |
wire_selector | select_u_wires = WirePlaneSelector(kUlayer, 0, 0) |
wire_selector | select_v_wires = WirePlaneSelector(kVlayer, 0, 0) |
wire_selector | select_w_wires = WirePlaneSelector(kWlayer, 0, 0) |
wire_selector | select_uvw_wires [3] |
const WirePlaneLayer_t | iplane2layer [3] = { kUlayer, kVlayer, kWlayer } |
This is the main entry point to the WCT. It provides a single command line method or optionally a family of fine-grained methods for setup and running.
One use of this is in the wire-cell
command line program. It may also be use to embed WCT into a larger application or framework.
Wire Cell uses Eigen3 arrays for holding large block data like the waveforms from one plane of one readout frame. This header provides a shim between Eigen3 and the rest of Wire Cell.
There are a few important rules:
Usage examples are given below.
Vector a 3-vector of double.
See also WireCell::Point.
Interpolationn helpers.
See test_interpolate.cxx.
This class provides a 2D array-like structure which holds things of templated type. It's not fancy.
Persist structured information.
Any and all structured information that needs to be loaded or saved uses the methods in WireCell::Persist to do so. The transient data model is that of JsonCPP's Json::Value. The persistent format is either JSON or if the toolkit has support compiled in, Jsonnet.
Note, "external" data which may be voluminous, complex or otherwise inconvenient to convert to JSON would not use WireCell::Persist but rather be brought between files and an IData model using an ISink/ISource.
See also WireCellUtil/Configuration.h for how the configuration layer uses Json::Value objects. Large configuration items like wire geometry and field response are also loaded as JSON.
A ray grid is defined by pair-wise layers of parallel, ordered pairs of rays.
This file includes the implemenation for a ray grid as well as classes and functions that operate with it.
See section in the WCT manual for details.
Solving attempts to invert the matrix equation m = G*b where m is a vector of measurements on channels, b is a vector of blobs and G is a matrix that relates the two.
Define a tiling of overlapping sets rays.
This is part of Ray Grid.
See the WCT manual for details.
Ress is an interface to wire-cell-ress
A system of units compatible with (taken from) CLHEP.
Code here helps read in data which follows the Wire Cell Toolkit wire data schema. See python module wirecell.util.wires.schema and sister submodules.
Some tools that operate on frame-related interfaces.
fixme: this should probably go into some WireCellItools package.
Provides information about an "anode face" which consists of a number of parallel wire planes, each consisting of a number of parallel wires.
Information includes:
Provides information about an "anode plane" which consists of a number of parallel wire planes as IWirePlane objects.
fixme: this has become kind of a kitchen sink.
A blob is a region in the 2D plane transverse to the drift direction. It is made up of a number of logically coplanar "layers". Each layer is bound by a pair of parallel rays. Rays may correspond to wires or to overall bounds of senitivity of the anode plane face. See manual for details.
A blob is assumed to exist in some context which provides its location along a drift direction aka time and a logical assocation with a particular anode face. See IBlobSet for example.
A blob set holds a collection of blobs.
See also ICluster which allows more rich associations.
IBlobSetProcessor consumes blob sets and sometimes produces them.
IChannel embodies static information about a single front end electronics channel to which some number of wire segments in an conductor feeds.
A channel response gives access to a per-channel response function. This is typically used to return the electronics response for a channel. Depending on implementation this may be an ideal response shared by all or it could be some measured or calibration response that differs for each channel.
A Channel Spectrum provides a discrete Fourier amplitude as a function of frequency.
An example implementation is a model of the noise on a given channel.
IChannelStatus provides information about each channel which potentially could change during the run.
A "cluster" (as defined here) is a graph connecting shared points to instances of a specific set of types of WCT data classes related to WC imaging. See node_t below for the supported types.
A clustering consumes blob sets and sometimes emits cluster objects.
A depo framer takes in a collection of depositions and produces a single frame that contains their associated signal waveforms. Excess depos may be dropped.
A field response provides access to a FieldResponse data structure. Use this interface instead of directly loading a response schema so that multiple components may share the same data without causing multiple loads.
This interface provides access to some "filter waveform" which is some discreetly sampled function.
A hydra has N input queues and M output queues each of a specified type. Not all queues may have elements. The implementation callable may leave elements in input queues for subsequent calls when new data exists.
A plane impact response provides information about a collection of impact responses for a plane. An impact response is a complex Fourier spectrum of some response (eg, field and possibly also electronics) to a point charge on a drift path that starts at the given impact position. Impact positions provide a regular subdivision along the pitch direction for a wire plane. Typically ten impact positions per wire region are used and with one impact position exactly aligned to a wire position.
A slice associates an IChannel with a value representing activity over some time span.
The time span of the slice is given in the WCT system of units. Typically it is some multiple of sampling ticks, but need not be.
The slice also caries an "ident" which definition is application-dependent.
A tiling consumes a time slice of channel samples and produces a set of blobs from it.
This is an interface to data about a waveform. It is a contiguous floating point sampling over a regular period and relative to some start (eg, start time).
Provides geometrical information about one wire plane in terms of its wire direction, pitch, bounding box and individual wires from which channel information can be derived.
A wire schema provides information on the detector/anode/face/plane/wire geometry hiearchy.
This information should be accessed through this interface instead of directly loading via the WireSchema code so that different components may share the information without leading to multiple loads of the data.
Some wire selectors.
Fixme: this isn't really appropriate for an interface package.
An AnodePlane provides wire-related and some volumetric geometrical information as well serving as the top of anode/face/plane organizational hierarchy for accessing this info. See also IAnodeFace and IWirePlane.
A blip source produces individual energy depositions in various ways.
This class "splats" depos directly into a frame without regards to much reality. It's only useful for gross, but fast debugging jobs. The frame it produces is the moral equivalent of post-SP.
Make a frame from depos using an ImpactTransform.
Make a frame from depos using an ImpactZipper.
See also the very similar DepoTransform which is newer and faster.
Convert ionization electrons into ADC.
This class assumes fine-grained field responses calculated at impact positions along lines across the wire pitch for each plane.
Digitizer converts voltage waveforms to integer ADC ones.
Resulting waveforms are still in floating-point form and should be round()'ed and truncated to whatever integer representation is wanted by some subsequent node.
An ElecResponse waveform is that due to sending a unit charge pulse into an amplifier with gain and shaping and a particular response function of the BNL cold electronics.
A noise model based on empirically measured noise spectra.
It requires configuration file holding a list of dictionary which provide association between wire length and the noise spectrum.
TBD: document JSON file format for providing spectra and any other parameters.
Define a pipeline facade over WCT nodes.
FIXME: this needs to move into the mithical "interface utilities" library along with much other stuff.
ImpactData represents the true charge distribution in time at the point in space where a field response function begins.
This component will output a "misconfigured" trace for each input trace.
It does this by filtering out an assumed electronics response function and applying a new one.
Note, traces are "misconfigured" independently even if multiple traces exist on the same channel.
By default the output traces will be sized larger than input by nsamples-1. If the "truncated" option is true then the output trace will be truncated to match the input size. this may cut off signal for traces smaller than the time where the electronics response functions are finite.
This component does not honor frame/trace tags. No tags will be considered on input and none are placed on output.
MultiDuctor - apply one of many possible ductors based on outcome of rules applied to input depos.
A list of independent "chains" are given. Each chain is applied to an input depo. A chain is a sequence of rules. Each rule is applied in turn to a depo until one matches. On a match, the ductor associated with the rule is given the depo and subsequent iteration of the chain is abandoned.
This frame source provides frames filled with noise.
Each time it is called it produces a fixed readout length of voltage-level noise which spans all channels.
This component will output a "ch-by-ch variation" trace for each input trace. Reference to "Misconfigure"
It does this by filtering out an assumed electronics response function and applying a new one from ch-by-ch electronics calibration.
By default the output traces will be sized larger than input by nsamples-1. If the "truncated" option is true then the output trace will be truncated to match the input size. this may cut off signal for traces smaller than the time where the electronics response functions are finite.
This component does not honor frame/trace tags. No tags will be considered on input and none are placed on output.
A PlaneDiffuser will return a queue of diffusions once enough depositions have been collected such that the queue represents all diffusions "close enough" to each wire. It implements a window across the wire pitch.
Gen::Random is an IRandom which is implemented with standard C++ <random>.
An RCResponse waveform is simple resistor-capacitor response.
A reframer takes makes a "rectangular" frame filled with samples from the tagged traces of its input. This new frame has exactly one trace for each channel and each trace is padded to span a uniform duration. These configuration paramters control how the new frame is shaped:
Vary field response to study systematics.
The static channel status component provides a simple way to set channel status via configuration. It does not provide for dynamic changes.
An IWirePlane.
A wire schema store based on loading data from files.
Make a new output frame with a set of traces selected from the input based on being in a set of channels and possibly tags.
Database Channel Selector: select channels from database
This component provides field response data as read in from a "WCT field response" JSON file
This component applies "compressed sensing" influenced signal processing based on an L1 norm minimzation which fits both a unipolar collection and a bipolar induction response to regions channels in shorted regions known to have a mix.
Inherently MicroBooNE-specific functions and classes
This component provides identical channel responses for all channels and which use the nominal electronics response parameterized by gain and shaping time.
This is Omnibus, a WCT app object that ties together signal processing components. It takes any number of frame filters and pushes one frame from source, through the pipeline to sink.
Remove all possible noise from a microboone-like detector.
This filter is a kitchen sink class and is a candidate for factoring.
This component provides per-channel responses based on a configuration data file.
Inherently protoDUNE-specific functions and classes Modified from Microboone.h
Save depos to a Numpy file.
Some frames to a Numpy file
typedef boost::graph_traits<cluster_graph_t>::edge_descriptor WireCell::cluster_edge_t |
Definition at line 89 of file ICluster.h.
typedef boost::adjacency_list<boost::setS, boost::vecS, boost::undirectedS, cluster_node_t> WireCell::cluster_graph_t |
Definition at line 87 of file ICluster.h.
Definition at line 105 of file ICluster.h.
typedef std::variant< size_t, IChannel::pointer, IWire::pointer, IBlob::pointer, ISlice::pointer, IChannel::shared_vector > WireCell::cluster_ptr_t |
The vertex property.
Definition at line 33 of file ICluster.h.
typedef boost::graph_traits<cluster_graph_t>::vertex_iterator WireCell::cluster_vertex_iter_t |
Definition at line 90 of file ICluster.h.
typedef boost::graph_traits<cluster_graph_t>::vertex_descriptor WireCell::cluster_vertex_t |
Definition at line 88 of file ICluster.h.
typedef Json::Value WireCell::Configuration |
The Wire Cell Toolkit configuration layer uses Json::Value objects for its transient data model.
The Configuration type is a recursive in that one Configuration object may contain others.
The WCT assumes an Object Configuration Protocol is implemented by the "client" code that uses the toolkit. See for example the reference implementation in the wire-cell command line program. This protocol consists of:
1) Creation of the list of Configuration objects, typically via WireCell::Persist::load().
2) Iterating this list and for each suitable Configuration object instantiating the appropriately matching IConfigurable via the WireCell::NamedFactory facility.
3) Obtaining the default Configuration object from the IConfigurable and merging the user-supplied on top of it.
4) Passing the resulting Configuration object to the IConfigurable::configure() method.
A suitable Configuration object must have two top level keys and may have a third optional key:
Definition at line 50 of file Configuration.h.
typedef std::set<IDepo::pointer, IDepoDriftCompare> WireCell::DepoTauSortedSet |
typedef boost::error_info<struct tag_errmsg, std::string> WireCell::errmsg |
Definition at line 54 of file Exceptions.h.
typedef std::set<IDiffusion::pointer, IDiffusionCompareLbegin> WireCell::IDiffusionSet |
Definition at line 66 of file IDiffusion.h.
typedef std::set<IWire::pointer, IWireCompareIndex> WireCell::IWireIndexSet |
typedef std::pair<IWire::pointer, IWire::pointer> WireCell::IWirePair |
typedef std::set<IWire::pointer, IWireCompareSegment> WireCell::IWireSegmentSet |
typedef std::set<IWire::pointer, IWireCompareIdent> WireCell::IWireSet |
typedef std::queue<boost::any> WireCell::Pipe |
Definition at line 22 of file GenPipeline.h.
typedef std::vector<Proc*> WireCell::Pipeline |
Definition at line 32 of file GenPipeline.h.
typedef D3Vector<double> WireCell::Point |
typedef D3Vector<float> WireCell::PointF |
typedef std::set<Point, ComparePoints> WireCell::PointSet |
typedef std::pair<Point, float> WireCell::PointValue |
typedef std::vector<PointValue> WireCell::PointValueVector |
typedef std::vector<Point> WireCell::PointVector |
typedef std::deque<boost::any> WireCell::queuedany |
Definition at line 181 of file GenPipeline.h.
typedef std::pair<Point, Point> WireCell::Ray |
typedef std::pair<Ray,Ray> WireCell::ray_pair_t |
typedef std::vector<ray_pair_t> WireCell::ray_pair_vector_t |
typedef std::vector<ScalarPoint> WireCell::ScalarField |
typedef std::pair<double, Vector> WireCell::ScalarPoint |
typedef std::pair<IImpactResponse::pointer,IImpactResponse::pointer> WireCell::TwoImpactResponses |
Definition at line 46 of file IPlaneImpactResponse.h.
typedef Point WireCell::Vector |
typedef boost::function<bool (IWire::pointer)> WireCell::wire_selector |
Definition at line 16 of file IWireSelectors.h.
Enumerate layer IDs. These are not indices!
Enumerator | |
---|---|
kUnknownLayer | |
kUlayer | |
kVlayer | |
kWlayer |
Definition at line 13 of file WirePlaneId.h.
WireCell::Configuration WireCell::append | ( | Configuration & | a, |
Configuration & | b | ||
) |
Return an array which is composed of the array b appended to the array a.
Append array b onto end of a and return a.
Definition at line 42 of file Configuration.cxx.
bool WireCell::ascending_index | ( | IWire::pointer | lhs, |
IWire::pointer | rhs | ||
) |
bool WireCell::ascending_time | ( | const WireCell::IDepo::pointer & | lhs, |
const WireCell::IDepo::pointer & | rhs | ||
) |
Compare two IDepo::pointer by time (ascending). x is used to break tie.
Definition at line 17 of file IDepo.cxx.
Determine if a ray hits a rectangular box aligned with the Cartesian axes.
See WireCelll::hit_square for definition of arguments and return value.
Definition at line 61 of file Intersection.cxx.
WireCell::Configuration WireCell::branch | ( | WireCell::Configuration | cfg, |
const std::string & | dotpath | ||
) |
Follow a dot.separated.path and return the branch there.
Definition at line 7 of file Configuration.cxx.
T WireCell::convert | ( | const Configuration & | cfg, |
const T & | def = T() |
||
) |
Convert a configuration value to a particular type.
For persistence use WireCell::Persist::load() and WireCell::Persist::dump(). The following functions provide some access methods which add some value beyond what Json::Value provides including some support for basic WCT types.
Definition at line 63 of file Configuration.h.
|
inline |
Definition at line 68 of file Configuration.h.
|
inline |
|
inline |
Definition at line 80 of file Configuration.h.
|
inline |
|
inline |
Definition at line 92 of file Configuration.h.
|
inline |
|
inline |
|
inline |
Definition at line 98 of file Configuration.h.
|
inline |
Definition at line 118 of file TagRules.h.
|
inline |
Definition at line 101 of file TagRules.h.
|
inline |
|
inline |
|
inline |
std::string WireCell::demangle | ( | const std::string & | name | ) |
IDepo::vector WireCell::depo_chain | ( | IDepo::pointer | recent | ) |
bool WireCell::descending_time | ( | const WireCell::IDepo::pointer & | lhs, |
const WireCell::IDepo::pointer & | rhs | ||
) |
std::size_t WireCell::fft_best_length | ( | size_t | nsamples, |
bool | keep_odd_even = false |
||
) |
Configuration WireCell::find | ( | Configuration & | lst, |
const std::string & | dotpath, | ||
const T & | val | ||
) |
Return dictionary in given list if it value at dotpath matches.
Definition at line 138 of file Configuration.h.
T WireCell::get | ( | Configuration | cfg, |
const std::string & | dotpath, | ||
const T & | def = T() |
||
) |
Get value in configuration at the dotted path from or return default.
Definition at line 149 of file Configuration.h.
int WireCell::hit_square | ( | int | axis0, |
const Ray & | bounds, | ||
const Point & | point, | ||
const Vector & | dir, | ||
Ray & | hits | ||
) |
Determine a 2D square is intersected by a 3D ray projected to its plane.
axis0 | is the axis number (0,1,2) to which the projected plane is perpendicular. |
bounds | is a raw from opposite corners of the bounding box. |
point | is a WireCell::Point from which a ray emanates. |
dir | is a WireCell::Vector in the direction of the ray. |
hits | is the returned intersection(s). |
Definition at line 8 of file Intersection.cxx.
double WireCell::memusage_resident | ( | ) |
double WireCell::memusage_shared | ( | ) |
Definition at line 50 of file MemUsage.cxx.
double WireCell::memusage_size | ( | ) |
std::vector<Type> WireCell::neighbors_oftype | ( | const cluster_indexed_graph_t & | g, |
const cluster_node_t & | n | ||
) |
Definition at line 120 of file ICluster.h.
std::vector<Type> WireCell::oftype | ( | const cluster_indexed_graph_t & | g | ) |
Definition at line 108 of file ICluster.h.
Definition at line 175 of file D3Vector.h.
|
inline |
|
inline |
|
inline |
Definition at line 142 of file Quantity.h.
Definition at line 160 of file D3Vector.h.
Definition at line 180 of file D3Vector.h.
|
inline |
Definition at line 156 of file Quantity.h.
|
inline |
|
inline |
Definition at line 163 of file Quantity.h.
|
inline |
|
inline |
Definition at line 149 of file Quantity.h.
Definition at line 165 of file D3Vector.h.
|
inline |
|
inline |
std::ostream & WireCell::operator<< | ( | std::ostream & | os, |
const WireCell::WirePlaneId & | wpid | ||
) |
std::ostream & WireCell::operator<< | ( | std::ostream & | o, |
const WireCell::WirePlaneLayer_t & | layer | ||
) |
Definition at line 91 of file WirePlaneId.cxx.
|
inline |
|
inline |
|
inline |
std::ostream& WireCell::operator<< | ( | std::ostream & | os, |
const D3Vector< T > & | vec | ||
) |
Definition at line 144 of file D3Vector.h.
|
inline |
|
inline |
|
inline |
|
inline |
void WireCell::put | ( | Configuration & | cfg, |
const std::string & | dotpath, | ||
const T & | val | ||
) |
Put value in configuration at the dotted path.
Definition at line 155 of file Configuration.h.
double WireCell::ray_length | ( | const Ray & | ray | ) |
WireCell::Ray WireCell::ray_pitch | ( | const Ray & | ray1, |
const Ray & | ray2 | ||
) |
WireCell::Vector WireCell::ray_unit | ( | const Ray & | ray | ) |
WireCell::Vector WireCell::ray_vector | ( | const Ray & | ray | ) |
double WireCell::ray_volume | ( | const Ray & | ray | ) |
std::string WireCell::type | ( | const T & | t | ) |
WireCell::Configuration WireCell::update | ( | WireCell::Configuration & | a, |
WireCell::Configuration & | b | ||
) |
Merge dictionary b into a, return a.
Definition at line 19 of file Configuration.cxx.
const WirePlaneLayer_t WireCell::iplane2layer[3] = { kUlayer, kVlayer, kWlayer } |
Definition at line 14 of file WirePlaneId.h.
wire_selector WireCell::select_all_wires = WirePlaneSelector(kUlayer|kVlayer|kWlayer, 0, 0) |
Definition at line 15 of file IWireSelectors.cxx.
wire_selector WireCell::select_u_wires = WirePlaneSelector(kUlayer, 0, 0) |
Definition at line 7 of file IWireSelectors.cxx.
wire_selector WireCell::select_uvw_wires |
Definition at line 10 of file IWireSelectors.cxx.
wire_selector WireCell::select_v_wires = WirePlaneSelector(kVlayer, 0, 0) |
Definition at line 8 of file IWireSelectors.cxx.
wire_selector WireCell::select_w_wires = WirePlaneSelector(kWlayer, 0, 0) |
Definition at line 9 of file IWireSelectors.cxx.