daq::FakeParticle Class Reference

FakeParticle class definiton. More...

Inheritance diagram for daq::FakeParticle:

Public Member Functions
	FakeParticle (fhicl::ParameterSet const &pset)
	Constructor. More...
	~FakeParticle ()
	Destructor. More...
virtual void	configure (const fhicl::ParameterSet &) override
	Interface for configuring the particular algorithm tool. More...
virtual void	overlayFakeParticle (detinfo::DetectorClocksData const &clockData, ArrayFloat &waveforms) override
	Creates a fake particle and overlays on the input fragment. More...
Public Member Functions inherited from daq::IFakeParticle
virtual	~IFakeParticle () noexcept=default
	Virtual Destructor. More...

Private Types
using	FFTPointer = std::unique_ptr< icarus_signal_processing::ICARUSFFT< double >>

Private Attributes
std::vector< size_t >	fWireEndPoints
size_t	fStartTick
float	fStartAngle
int	fNumElectronsPerMM
size_t	fPlaneToSimulate
float	fMMPerTick
float	fMMPerWire
float	fTanThetaTW
float	fTanTheta
float	fSinTheta
float	fCosTheta
std::vector< size_t >	fTickEndPoints
icarusutil::TimeVec	fFFTTimeVec
FFTPointer	fFFT
const geo::Geometry *	fGeometry
const detinfo::DetectorProperties *	fDetector
icarusutil::SignalShapingICARUSService *	fSignalShapingService

Additional Inherited Members
Public Types inherited from daq::IFakeParticle
using	VectorShort = std::vector< short >
	Creates a fake particle and overlays on the input fragment. More...
using	VectorFloat = std::vector< float >
using	ArrayShort = std::vector< VectorShort >
using	ArrayFloat = std::vector< VectorFloat >

Detailed Description

FakeParticle class definiton.

Definition at line 41 of file FakeParticle_tool.cc.

Member Typedef Documentation

using daq::FakeParticle::FFTPointer = std::unique_ptr<icarus_signal_processing::ICARUSFFT<double>>

private

Definition at line 91 of file FakeParticle_tool.cc.

Constructor & Destructor Documentation

daq::FakeParticle::FakeParticle ( fhicl::ParameterSet const &  pset )

explicit

Constructor.

Parameters

pset

Definition at line 100 of file FakeParticle_tool.cc.

{
    this->configure(pset);

    return;
}

daq::FakeParticle::~FakeParticle

(

)

Destructor.

Definition at line 109 of file FakeParticle_tool.cc.

{
}

Member Function Documentation

void daq::FakeParticle::configure ( const fhicl::ParameterSet &  pset )

overridevirtual

Interface for configuring the particular algorithm tool.

Parameters

ParameterSet

The input set of parameters for configuration

Implements daq::IFakeParticle.

Definition at line 114 of file FakeParticle_tool.cc.

{
    fWireEndPoints     = pset.get<std::vector<size_t>>("WireEndPoints", std::vector<size_t>()={25,550});
    fStartTick         = pset.get<size_t             >("StartTick",                               1000);
    fStartAngle        = pset.get<float              >("StartAngle",                                45);
    fNumElectronsPerMM = pset.get<int                >("NumElectronsPerMM",                       6000);
    fPlaneToSimulate   = pset.get<size_t             >("PlaneToSimulate",                            2);
                                  
    fGeometry           = art::ServiceHandle<geo::Geometry const>{}.get();
    fSignalShapingService = art::ServiceHandle<icarusutil::SignalShapingICARUSService>{}.get();

    // Convert ticks in us to mm by taking the drift velocity and multiplying by the tick period
    auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
    auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clockData);
    double driftVelocity = detProp.DriftVelocity() * 10.;   // should be mm/us
    double samplingRate  = sampling_rate(clockData) / 1000.;  // sampling rate returned in ns

    fMMPerTick = driftVelocity * samplingRate;

    fMMPerWire = fGeometry->WirePitch() * 10.;  // wire pitch returned in cm, want mm

    // Get slope (tan(theta)) and related angles
    fTanTheta   = std::tan(fStartAngle * M_PI / 180.);
    fCosTheta   = 1. / sqrt(1. + fTanTheta * fTanTheta);
    fSinTheta   = fTanTheta * fCosTheta;

    fTanThetaTW = fTanTheta * fMMPerWire / fMMPerTick;

    // Constrain x range
    fWireEndPoints[1] = std::min(fWireEndPoints[1],size_t(576));

    // Now compute the tick start/end points
    fTickEndPoints.push_back(fStartTick);
    fTickEndPoints.push_back(size_t(std::round(fTanThetaTW * float(fWireEndPoints[1] - fWireEndPoints[0]) + fStartTick)));

    // Check to see if we have run off the end of our frame (max 576,4096)
    if (fTickEndPoints[1] > size_t(4096))
    {
        // Probably should worry about the 90 degree case...
        if (std::fabs(fStartAngle) < 90)
        {
            fWireEndPoints[1] = std::round(float(4096 - fStartTick) / fTanTheta + fWireEndPoints[0]);
            fTickEndPoints[1] = 4096;
        }
        else
            fWireEndPoints[1] = fWireEndPoints[0];
    }

    // Now set up our plans for doing the convolution
    int numberTimeSamples = fDetector->NumberTimeSamples();

    fFFTTimeVec.resize(numberTimeSamples,0.);

    fFFT = std::make_unique<icarus_signal_processing::ICARUSFFT<double>>(numberTimeSamples);

    return;
}

void daq::FakeParticle::overlayFakeParticle ( detinfo::DetectorClocksData const &  clockData, ArrayFloat &  waveforms  )

overridevirtual

Creates a fake particle and overlays on the input fragment.

Parameters

waveforms

The waveform container to place fake particle on

Implements daq::IFakeParticle.

Definition at line 172 of file FakeParticle_tool.cc.

{
    // We have assumed the input waveform array will have 576 wires... 
    // Our "range" must be contained within that. By assumption we start at wire 0, so really just need
    // to set the max range 
    size_t maxWire = std::min(waveforms.size(),fWireEndPoints[1]);

    // Create a temporary waveform to handle the input charge
//    icarusutil::TimeVec tempWaveform(waveforms[0].size(),0.);

    // Also recover the gain
    float asicGain = fSignalShapingService->GetASICGain(0) * sampling_rate(clockData) / 1000.;  // something like 67.4

    // Get a base channel number for the plane we want
    raw::ChannelID_t channel = fGeometry->PlaneWireToChannel(fPlaneToSimulate, 0);

    // Recover the response function information for this channel
    const icarus_tool::IResponse& response = fSignalShapingService->GetResponse(channel);

    // Also want the time offset for this channel
    int timeOffset = fSignalShapingService->ResponseTOffset(channel);

    // Loop over the wire range
    for(size_t wireIdx = fWireEndPoints[0]; wireIdx < maxWire; wireIdx++)
    {
        // As the track angle becomes more parallel to the electron drift direction there will be more charge
        // deposited per mm that will impact a given wire. So we need to try to accommodate this here.
        // Start by computing the starting tick (based on how far we have gone so far)
        size_t startTick = size_t(fTanThetaTW * float(wireIdx - fWireEndPoints[0])) + fTickEndPoints[0];

        // If this has gone outside the maximum tick then we are done
        if (!(startTick < fTickEndPoints[1] && startTick < fFFTTimeVec.size())) break;

        // Begin by computing the number of ticks for this given wire, converted to tick units and 
        // always at least one tick
        size_t deltaTicks = size_t(fMMPerWire * std::fabs(fTanTheta)) + 1;
        size_t endTick    = startTick + deltaTicks;

        // Trim back if we look to step outside of the max range 
        endTick = std::min(endTick,fTickEndPoints[1]);
        endTick = std::min(endTick,fFFTTimeVec.size());

        // Ok, now loop through the ticks and deposit charge. 
        // This will be the number of electrons per mm (input) 
        // x the total arc length of track for this step
        float arcLenPerWire    = fMMPerWire / fCosTheta;
        float arcLenPerTick    = arcLenPerWire / float(deltaTicks);
        float numElectronsWire = fNumElectronsPerMM * arcLenPerWire;
        float fracElecPerTick  = numElectronsWire * arcLenPerTick / arcLenPerWire;

        // Make sure the waveform is zeroed
        std::fill(fFFTTimeVec.begin(),fFFTTimeVec.end(),0.);

        // Now loop through the ticks and deposit charge
        for(size_t tickIdx = startTick; tickIdx < endTick; tickIdx++)
            fFFTTimeVec[tickIdx] = fracElecPerTick / asicGain;

        // Convolute with the response functions
//        fSignalShapingService->Convolute(channel, fFFTTimeVec);
        fFFT->convolute(fFFTTimeVec, response.getConvKernel(), timeOffset);

        // And now add this to the waveform in question 
        VectorFloat& waveform = waveforms[wireIdx];

        std::transform(waveform.begin(),waveform.end(),fFFTTimeVec.begin(),waveform.begin(),std::plus<float>());
    }

    return;
}

Member Data Documentation

float daq::FakeParticle::fCosTheta

private

Definition at line 86 of file FakeParticle_tool.cc.

const detinfo::DetectorProperties* daq::FakeParticle::fDetector

private

Definition at line 96 of file FakeParticle_tool.cc.

FFTPointer daq::FakeParticle::fFFT

private

Definition at line 93 of file FakeParticle_tool.cc.

icarusutil::TimeVec daq::FakeParticle::fFFTTimeVec

private

Definition at line 89 of file FakeParticle_tool.cc.

const geo::Geometry* daq::FakeParticle::fGeometry

private

Definition at line 95 of file FakeParticle_tool.cc.

float daq::FakeParticle::fMMPerTick

private

Definition at line 81 of file FakeParticle_tool.cc.

float daq::FakeParticle::fMMPerWire

private

Definition at line 82 of file FakeParticle_tool.cc.

int daq::FakeParticle::fNumElectronsPerMM

private

Definition at line 77 of file FakeParticle_tool.cc.

size_t daq::FakeParticle::fPlaneToSimulate

private

Definition at line 78 of file FakeParticle_tool.cc.

icarusutil::SignalShapingICARUSService* daq::FakeParticle::fSignalShapingService

private

Definition at line 97 of file FakeParticle_tool.cc.

float daq::FakeParticle::fSinTheta

private

Definition at line 85 of file FakeParticle_tool.cc.

float daq::FakeParticle::fStartAngle

private

Definition at line 76 of file FakeParticle_tool.cc.

size_t daq::FakeParticle::fStartTick

private

Definition at line 75 of file FakeParticle_tool.cc.

float daq::FakeParticle::fTanTheta

private

Definition at line 84 of file FakeParticle_tool.cc.

float daq::FakeParticle::fTanThetaTW

private

Definition at line 83 of file FakeParticle_tool.cc.

std::vector<size_t> daq::FakeParticle::fTickEndPoints

private

Definition at line 87 of file FakeParticle_tool.cc.

std::vector<size_t> daq::FakeParticle::fWireEndPoints

private

Definition at line 74 of file FakeParticle_tool.cc.

---

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

• FakeParticle_tool.cc