wcls::SimDepoSource Class Reference

#include <SimDepoSource.h>

Inheritance diagram for wcls::SimDepoSource:

Public Member Functions
	SimDepoSource ()
virtual	~SimDepoSource ()
virtual void	visit (art::Event &event)
	IArtEventVisitor. More...
virtual bool	operator() (WireCell::IDepo::pointer &out)
	IDepoSource. More...
virtual WireCell::Configuration	default_configuration () const
	IConfigurable. More...
virtual void	configure (const WireCell::Configuration &config)
Public Member Functions inherited from wcls::IArtEventVisitor
virtual	~IArtEventVisitor ()
virtual void	produces (art::ProducesCollector &collector)

Private Attributes
std::deque< WireCell::IDepo::pointer >	m_depos
bits::DepoAdapter *	m_adapter
art::InputTag	m_inputTag
art::InputTag	m_assnTag

Detailed Description

Definition at line 42 of file SimDepoSource.h.

Constructor & Destructor Documentation

SimDepoSource::SimDepoSource

(

)

Definition at line 86 of file SimDepoSource.cxx.

    : m_adapter(nullptr)
{
}

SimDepoSource::~SimDepoSource ( )

virtual

Definition at line 91 of file SimDepoSource.cxx.

{
    if (m_adapter) {
        delete m_adapter;
        m_adapter = nullptr;
    }
}

Member Function Documentation

void SimDepoSource::configure ( const WireCell::Configuration &  config )

virtual

Definition at line 117 of file SimDepoSource.cxx.

{
    if (m_adapter) {
        delete m_adapter;
        m_adapter = nullptr;
    }
    double scale = WireCell::get(cfg, "scale", 1.0);

    std::string model_tn = WireCell::get<std::string>(cfg, "model", "");
    std::string model_type = "";
    if (!model_tn.empty()) {
        WireCell::String::split(model_tn)[0];
    }

    if (model_type == "" or model_type == "electrons") {
        m_adapter = new wcls::bits::ElectronsAdapter(scale);
    }
    else {
        auto model = WireCell::Factory::lookup_tn<WireCell::IRecombinationModel>(model_tn);
        if (!model) {
            std::cerr << "wcls::SimDepoSource: unknown recombination model: \"" << model_tn << "\"\n";
            return;             // I should throw something here!
        }
        if (model_type == "MipRecombination") {
            m_adapter = new wcls::bits::PointAdapter(model, scale);
        }
        if (model_type == "BirksRecombination" || model_type == "BoxRecombination") {
            m_adapter = new wcls::bits::StepAdapter(model, scale);
        }
    }

    m_inputTag = cfg["art_tag"].asString();
    m_assnTag = cfg["assn_art_tag"].asString();
}

WireCell::Configuration SimDepoSource::default_configuration ( ) const

virtual

IConfigurable.

Definition at line 99 of file SimDepoSource.cxx.

{
    WireCell::Configuration cfg;

    // An empty model or the special model "electrons" means to take
    // precalcualted input NumElectrons.  Anything else means some
    // recombination model is used.
    cfg["model"] = "";
    // Multiply this number to the number of electrons before forming
    // a WC depo.
    cfg["scale"] = 1.0;

    // For locating input in the art::Event
    cfg["art_tag"] = "";     // eg, "plopper:bogus"
    cfg["assn_art_tag"] = ""; // eg, "largeant"

    return cfg;
}

bool SimDepoSource::operator() ( WireCell::IDepo::pointer &  out )

virtual

IDepoSource.

Definition at line 258 of file SimDepoSource.cxx.

{
    if (m_depos.empty()) {
        return false;
    }

    out = m_depos.front();
    m_depos.pop_front();

    // if (!out) {
    //     std::cerr << "SimDepoSource: reached EOS\n";
    // }
    // else {
    //     std::cerr << "SimDepoSource: t=" << out->time()/units::us << "us,"
    //               << " r=" << out->pos()/units::cm << "cm, " << " q=" << out->charge() << "\n";
    // }
    return true;
}

void SimDepoSource::visit ( art::Event &  event )

virtual

IArtEventVisitor.

Implements wcls::IArtEventVisitor.

Definition at line 153 of file SimDepoSource.cxx.

{
    art::Handle< std::vector<sim::SimEnergyDeposit> > sedvh;

    bool okay = event.getByLabel(m_inputTag, sedvh);
    if (!okay) {
        std::string msg = "SimDepoSource failed to get sim::SimEnergyDeposit from art tag: " + m_inputTag.encode();
        std::cerr << msg << std::endl;
        THROW(WireCell::RuntimeError() << WireCell::errmsg{msg});
    }
    //else if (sedvh->empty()) return;

    const size_t ndepos = sedvh->size();

    std::cerr << "SimDepoSource got " << ndepos
              << " depos from art tag \"" << m_inputTag
              << "\" returns: " << (okay ? "okay" : "fail") << std::endl;

    if (!m_depos.empty()) {
        std::cerr << "SimDepoSource dropping " << m_depos.size()
                  << " unused, prior depos\n";
        m_depos.clear();
    }

    // associate the input SED with the other set of SED (eg, before SCE)
    std::vector<sim::SimEnergyDeposit> assn_sedv;
    if (m_assnTag!="") {
        art::Handle< std::vector<sim::SimEnergyDeposit> > assn_sedvh;
        okay = event.getByLabel(m_assnTag, assn_sedvh);
        if (!okay) {
            std::string msg = "SimDepoSource failed to get sim::SimEnergyDeposit from art tag: " + m_assnTag.encode();
            std::cerr << msg << std::endl;
            THROW(WireCell::RuntimeError() << WireCell::errmsg{msg});
        }
        else {
            std::cout << "Larwirecell::SimDepoSource got " << assn_sedvh->size() 
                      << " associated depos from " << m_assnTag << std::endl;
            assn_sedv.insert(assn_sedv.end(), assn_sedvh->begin(), assn_sedvh->end() );
        }
        // safty check for the associated SED
        if (ndepos != assn_sedv.size()) {
            std::string msg = "Larwirecell::SimDepoSource Inconsistent size of SimDepoSources";
            std::cerr << msg << std::endl;
            THROW(WireCell::RuntimeError() << WireCell::errmsg{msg});
        }
    }

    for (size_t ind=0; ind<ndepos; ++ind) {
        auto const& sed = sedvh->at(ind);
        auto pt = sed.MidPoint();
        const WireCell::Point wpt(pt.x()*units::cm, pt.y()*units::cm, pt.z()*units::cm);
        double wt = sed.Time()*units::ns;
        double wq = (*m_adapter)(sed);
        int wid = sed.TrackID();
        int pdg = sed.PdgCode();
        double we = sed.Energy()*units::MeV;

        if (assn_sedv.size() == 0) {
            WireCell::IDepo::pointer depo
                = std::make_shared<WireCell::SimpleDepo>(wt, wpt, wq, nullptr, 0.0, 0.0, wid, pdg, we);
            m_depos.push_back(depo);
            // std::cerr << ind << ": t=" << wt/units::us << "us,"
            //           << " r=" << wpt/units::cm << "cm, "
            //           << " q=" << wq
            //           << " e=" << we/units::MeV << "\n";
        }
        else {
            auto const& sed1 = assn_sedv.at(ind);
            auto pt1 = sed1.MidPoint();
            const WireCell::Point wpt1(pt1.x()*units::cm, pt1.y()*units::cm, pt1.z()*units::cm);
            double wt1 = sed1.Time()*units::ns;
            double wq1 = (*m_adapter)(sed1);
            int wid1 = sed1.TrackID();
            int pdg1 = sed1.PdgCode();
            double we1 = sed1.Energy()*units::MeV;

            WireCell::IDepo::pointer assn_depo
            = std::make_shared<WireCell::SimpleDepo>(wt1, wpt1, wq1, nullptr, 0.0, 0.0, wid1, pdg1, we1);

            WireCell::IDepo::pointer depo
                = std::make_shared<WireCell::SimpleDepo>(wt, wpt, wq, assn_depo, 0.0, 0.0, wid, pdg, we);
            m_depos.push_back(depo);
            // std::cerr << ind << ": t1=" << wt1/units::us << "us,"
            //           << " r1=" << wpt1/units::cm << "cm, "
            //           << " q1=" << wq1
            //           << " e1=" << we1/units::MeV << "\n";
        }
    }

    // empty "ionization": no TPC activity
    if (ndepos == 0) {
            WireCell::Point wpt(0, 0, 0);
            WireCell::IDepo::pointer depo
                    = std::make_shared<WireCell::SimpleDepo>(0, wpt, 0, nullptr, 0.0, 0.0);
            m_depos.push_back(depo);
    }

    // don't trust user to honor time ordering.
    std::sort(m_depos.begin(), m_depos.end(), WireCell::ascending_time);
    std::cerr << "SimDepoSource: ready with " << m_depos.size() << " depos spanning: ["
              << m_depos.front()->time()/units::us << ", "
              << m_depos.back()->time()/units::us << "]us\n";
    m_depos.push_back(nullptr); // EOS marker
}

Member Data Documentation

bits::DepoAdapter* wcls::SimDepoSource::m_adapter

private

Definition at line 61 of file SimDepoSource.h.

art::InputTag wcls::SimDepoSource::m_assnTag

private

Definition at line 64 of file SimDepoSource.h.

std::deque<WireCell::IDepo::pointer> wcls::SimDepoSource::m_depos

private

Definition at line 60 of file SimDepoSource.h.

art::InputTag wcls::SimDepoSource::m_inputTag

private

Definition at line 63 of file SimDepoSource.h.

---

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

• larwirecell/larwirecell/Components/SimDepoSource.h
• larwirecell/larwirecell/Components/SimDepoSource.cxx