detsim::SimReadoutBoardICARUS Class Reference

Inheritance diagram for detsim::SimReadoutBoardICARUS:

Classes
class	ResponseParams

Public Member Functions
	SimReadoutBoardICARUS (fhicl::ParameterSet const &pset)
virtual	~SimReadoutBoardICARUS ()
void	produce (art::Event &evt)
void	beginJob ()
void	endJob ()
void	reconfigure (fhicl::ParameterSet const &p)

Private Types
using	TPCIDVec = std::vector< geo::TPCID >
using	FFTPointer = std::unique_ptr< icarus_signal_processing::ICARUSFFT< double >>

Private Member Functions
void	MakeADCVec (std::vector< short > &adc, icarusutil::TimeVec const &noise, icarusutil::TimeVec const &charge, float ped_mean) const

Private Attributes
art::InputTag	fDriftEModuleLabel
	module making the ionization electrons More...
std::string	fOutInstanceLabel
	The label to apply to the output data product. More...
bool	fProcessAllTPCs
	If true we process all TPCs. More...
unsigned int	fCryostat
	If ProcessAllTPCs is false then cryostat to use. More...
TPCIDVec	fTPCVec
	List of TPCs to process for this instance of the module. More...
raw::Compress_t	fCompression
	compression type to use More...
unsigned int	fNTimeSamples
	number of ADC readout samples in all readout frames (per event) More...
std::map< double, int >	fShapingTimeOrder
bool	fSimDeadChannels
	if True, simulate dead channels using the ChannelStatus service. If false, do not simulate dead channels More...
bool	fSuppressNoSignal
	If no signal on wire (simchannel) then suppress the channel. More...
bool	fSmearPedestals
	If True then we smear the pedestals. More...
int	fNumChanPerMB
	Number of channels per motherboard. More...
std::unique_ptr < icarus_tool::IGenNoise >	fNoiseTool
	Tool for generating noise. More...
bool	fMakeHistograms
bool	fTest
std::vector< sim::SimChannel >	fTestSimChannel_v
size_t	fTestWire
std::vector< size_t >	fTestIndex
std::vector< double >	fTestCharge
TH1F *	fSimCharge
TH2F *	fSimChargeWire
CLHEP::HepRandomEngine &	fPedestalEngine
CLHEP::HepRandomEngine &	fUncNoiseEngine
CLHEP::HepRandomEngine &	fCorNoiseEngine
const float	adcsaturation = 4095
FFTPointer	fFFT
const geo::GeometryCore &	fGeometry
icarusutil::SignalShapingICARUSService *	fSignalShapingService
const icarusDB::IICARUSChannelMap *	fChannelMap

Detailed Description

Definition at line 71 of file SimReadoutBoardICARUS_module.cc.

Member Typedef Documentation

using detsim::SimReadoutBoardICARUS::FFTPointer = std::unique_ptr<icarus_signal_processing::ICARUSFFT<double>>

private

Definition at line 137 of file SimReadoutBoardICARUS_module.cc.

using detsim::SimReadoutBoardICARUS::TPCIDVec = std::vector<geo::TPCID>

private

Definition at line 89 of file SimReadoutBoardICARUS_module.cc.

Constructor & Destructor Documentation

detsim::SimReadoutBoardICARUS::SimReadoutBoardICARUS ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 149 of file SimReadoutBoardICARUS_module.cc.

    : EDProducer{pset}
    , fPedestalEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this, "HepJamesRandom", "pedestal", pset, "SeedPedestal"))
    , fUncNoiseEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this, "HepJamesRandom", "noise",    pset, "Seed"))
    , fCorNoiseEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this, "HepJamesRandom", "cornoise", pset, "Seed"))
    , fGeometry(*lar::providerFrom<geo::Geometry>())
    , fChannelMap(art::ServiceHandle<icarusDB::IICARUSChannelMap const>{}.get())

detsim::SimReadoutBoardICARUS::~SimReadoutBoardICARUS ( )

virtual

Definition at line 167 of file SimReadoutBoardICARUS_module.cc.

{}

Member Function Documentation

void detsim::SimReadoutBoardICARUS::beginJob

(

)

Definition at line 215 of file SimReadoutBoardICARUS_module.cc.

{
    // get access to the TFile service
    art::ServiceHandle<art::TFileService> tfs;
    
    // If in test mode create a test data set
    if(fTest)
    {
        if(fGeometry.Nchannels()<=fTestWire)
            throw cet::exception(__FUNCTION__)<<"Invalid test wire channel: "<<fTestWire;
        std::vector<unsigned int> channels;
        for(auto const& plane_id : fGeometry.IteratePlaneIDs())
            channels.push_back(fGeometry.PlaneWireToChannel(plane_id.Plane,fTestWire));
        double xyz[3] = { std::numeric_limits<double>::max() };
        for(auto const& ch : channels)
        {
            fTestSimChannel_v.push_back(sim::SimChannel(ch));
            for(size_t i=0; i<fTestIndex.size(); ++i)
            {
                fTestSimChannel_v.back().AddIonizationElectrons(-1,
                                                                fTestIndex[i],
                                                                fTestCharge[i],
                                                                xyz,
                                                                std::numeric_limits<double>::max());
            }
        }
    }
    
    fSimCharge     = tfs->make<TH1F>("fSimCharge", "simulated charge", 150, 0, 1500);
    fSimChargeWire = tfs->make<TH2F>("fSimChargeWire", "simulated charge", 5600,0.,5600.,500, 0, 1500);
    
    return;
}

void detsim::SimReadoutBoardICARUS::endJob

(

)

Definition at line 249 of file SimReadoutBoardICARUS_module.cc.

{}

void detsim::SimReadoutBoardICARUS::MakeADCVec ( std::vector< short > &  adc, icarusutil::TimeVec const &  noise, icarusutil::TimeVec const &  charge, float  ped_mean  ) const

private

Definition at line 497 of file SimReadoutBoardICARUS_module.cc.

{
    for(unsigned int i = 0; i < fNTimeSamples; ++i)
    {
        float adcval = noisevec[i] + chargevec[i] + ped_mean;

        adcval = std::max(float(0.), std::min(adcval, adcsaturation));

        adcvec[i] = std::round(adcval);
    }// end loop over signal size
    // compress the adc vector using the desired compression scheme,
    // if raw::kNone is selected nothing happens to adcvec
    // This shrinks adcvec, if fCompression is not kNone.
    raw::Compress(adcvec, fCompression);
    
    return;
}

void detsim::SimReadoutBoardICARUS::produce

(

art::Event &

evt

)

Definition at line 251 of file SimReadoutBoardICARUS_module.cc.

{
    //--------------------------------------------------------------------
    //
    // Get all of the services we will be using
    //
    //--------------------------------------------------------------------
    
    //get pedestal conditions
//    const lariov::DetPedestalProvider& pedestalRetrievalAlg = art::ServiceHandle<lariov::DetPedestalService>()->GetPedestalProvider();
    
    //channel status for simulating dead channels
    const lariov::ChannelStatusProvider& ChannelStatusProvider = art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();
    
    auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
    
    // get the geometry to be able to figure out signal types and chan -> plane mappings
    const raw::ChannelID_t maxChannel = fGeometry.Nchannels();

    //--------------------------------------------------------------------
    //
    // Get the SimChannels, which we will use to produce RawDigits
    //
    //--------------------------------------------------------------------
    // make a vector of const sim::SimChannel* that has same number
    // of entries as the number of channels in the detector
    // and set the entries for the channels that have signal on them
    // using the chanHandle
    std::vector<const sim::SimChannel*> channels(maxChannel,nullptr);
    if(!fTest)
    {
        std::vector<const sim::SimChannel*> chanHandle;
        evt.getView(fDriftEModuleLabel,chanHandle);
        
        for(const auto& simChannel : chanHandle) channels.at(simChannel->Channel()) = simChannel;
    }
    else
        for(const auto& testChannel : fTestSimChannel_v) channels.at(testChannel.Channel()) = &testChannel;
    
    // make a unique_ptr of sim::SimDigits that allows ownership of the produced
    // digits to be transferred to the art::Event after the put statement below
    std::unique_ptr< std::vector<raw::RawDigit>> digcol(new std::vector<raw::RawDigit>);
    digcol->reserve(maxChannel);
    //--------------------------------------------------------------------
    //
    // Loop over channels a second time and produce the RawDigits by adding together
    // pedestal, noise, and direct & induced charges
    //
    //--------------------------------------------------------------------
    
    // vectors for working in the following for loop
    std::vector<short>  adcvec(fNTimeSamples, 0);
    icarusutil::TimeVec chargeWork(fNTimeSamples,0.);
    icarusutil::TimeVec zeroCharge(fNTimeSamples,0.);
    icarusutil::TimeVec noisetmp(fNTimeSamples,0.);
    
    // make sure chargeWork is correct size
    if (chargeWork.size() < fNTimeSamples) throw std::range_error("SimReadoutBoardICARUS: chargeWork vector too small");
    
    //detector properties information
    auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt);
    
    // Let the tools know to update to the next event
    fNoiseTool->nextEvent();

    // Plan is to loop over readout boards, rejecting any that are not in the TPC list
    // For any good readout boards we loop through the channels. 

    // Get the board ids for this fragment
    const icarusDB::TPCReadoutBoardToChannelMap& readoutBoardToChannelMap = fChannelMap->getReadoutBoardToChannelMap();

    unsigned int boardCount(0);

    std::set<raw::ChannelID_t> channelIDSet;

    for(const auto& boardPair : readoutBoardToChannelMap)
    {
        // A little song and dance to make sure this board is in our TPC group
        // What we need is a proper mapping but because we can have channels which are not valid for the geometry
        // service we have a little thing we have to go through here...
        std::vector<geo::WireID> wireIDVec;

        for(const auto& channelPair : boardPair.second.second)
        {
            wireIDVec = fGeometry.ChannelToWire(channelPair.first);

            if (wireIDVec.size() > 0) break;
        }

        if (wireIDVec.empty()) continue;  // Can this happen?
        
        bool         goodBoard(false);
        unsigned int cryostat(0);
        unsigned int tpc(0);

        for(geo::TPCID const& tpcid : fTPCVec)
        {
            if (tpcid.Cryostat == wireIDVec[0].Cryostat && tpcid.TPC == wireIDVec[0].TPC)
            {
                goodBoard = true;
                cryostat  = tpcid.Cryostat;
                tpc       = tpcid.TPC;
                break;
            }
        }

        if (!goodBoard) continue;

        // For this board loop over channels
        for(const auto& channelPair : boardPair.second.second)
        {
            // Recover channel and plane info
            raw::ChannelID_t channel = channelPair.first;
            size_t           plane   = channelPair.second;
            geo::PlaneID     planeID(cryostat,tpc,plane);

            if (channelIDSet.find(channel) != channelIDSet.end())
            {
                std::cout << "############### Found already used channel! channelID: " << channel << std::endl;
            }
            channelIDSet.insert(channel);

            //clean up working vectors from previous iteration of loop
            adcvec.resize(fNTimeSamples, 0);  //compression may have changed the size of this vector
            noisetmp.resize(fNTimeSamples, 0.);     //just in case

            //use channel number to set some useful numbers

            //Get pedestal with random gaussian variation
            float ped_mean = 2048; //pedestalRetrievalAlg.PedMean(channel);

            if (fSmearPedestals )
            {
                CLHEP::RandGaussQ rGaussPed(fPedestalEngine, 0.0, 3.0); //pedestalRetrievalAlg.PedRms(channel));
                ped_mean += rGaussPed.fire();
            }

            //Generate Noise
            double noise_factor(0.);
            double shapingTime  = fSignalShapingService->GetShapingTime(plane);
            auto   tempNoiseVec = fSignalShapingService->GetNoiseFactVec();

            if (fShapingTimeOrder.find( shapingTime ) != fShapingTimeOrder.end() )
                noise_factor = tempNoiseVec[plane].at( fShapingTimeOrder.find( shapingTime )->second );
            //Throw exception...
            else
            {
                throw cet::exception("SimReadoutBoardICARUS")
                << "\033[93m"
                << "Shaping Time received from signalservices_icarus.fcl is not one of allowed values"
                << std::endl
                << "Allowed values: 0.6, 1.0, 1.3, 3.0 usec"
                << "\033[00m"
                << std::endl;
            }

            // Check where this wire is located
            std::vector<geo::WireID> widVec = fGeometry.ChannelToWire(channel);

            // For now skip the channels with no info
//            if (widVec.empty()) continue;
//            unsigned int wire(0);
//            if (widVec.size() > 0) wire = widVec[0].Wire;

//            if (cryostat == 0 && tpc == 0) std::cout << "    -wireIdx " << wireIdx++ << ", wire: " << wire << ", plane " << plane << " channel " << channel << ", noise_factor: " << noise_factor << ", planeID: " << planeID << std::endl;

            // Use the desired noise tool to actually generate the noise on this wire
            fNoiseTool->generateNoise(fUncNoiseEngine,
                                      fCorNoiseEngine,
                                      noisetmp,
                                      detProp,
                                      noise_factor,
                                      planeID,
                                      boardPair.first);

            // Recover the SimChannel (if one) for this channel
            const sim::SimChannel* simChan = channels[channel];

            // If there is something on this wire, and it is not dead, then add the signal to the wire
            if(simChan && !(fSimDeadChannels && (ChannelStatusProvider.IsBad(channel) || !ChannelStatusProvider.IsPresent(channel))))
            {
                double gain         = fSignalShapingService->GetASICGain(channel) * sampling_rate(clockData) * 1.e-3; // Gain returned is electrons/us, this converts to electrons/tick
                int    timeOffset   = fSignalShapingService->ResponseTOffset(channel);

                // Recover the response function information for this channel
                const icarus_tool::IResponse& response = fSignalShapingService->GetResponse(channel);
                
                std::fill(chargeWork.begin(), chargeWork.end(), 0.);

                // loop over the tdcs and grab the number of electrons for each
                for(size_t tick = 0; tick < fNTimeSamples; tick++)
                {
                    // Note that we attempt to explicitly remove the time offsets between the planes and leave it to the response
                    // functions to handle this. So we reference the time to the first plane
                    int tdc = clockData.TPCTick2TDC(tick + detProp.GetXTicksOffset(planeID) - detProp.GetXTicksOffset(geo::PlaneID(cryostat,tpc,0)));

                    // continue if tdc < 0
                    if( tdc < 0 ) continue;

                    double charge = simChan->Charge(tdc);  // Charge returned in number of electrons

                    chargeWork[tick] += charge/gain;  // # electrons / (# electrons/tick)
                } // loop over tdcs
                // now we have the tempWork for the adjacent wire of interest
                // convolve it with the appropriate response function
                fFFT->convolute(chargeWork, response.getConvKernel(), timeOffset);

                // "Make" the ADC vector
                MakeADCVec(adcvec, noisetmp, chargeWork, ped_mean);
            }
            // "Make" an ADC vector with zero charge added
            else MakeADCVec(adcvec, noisetmp, zeroCharge, ped_mean);

            // add this digit to the collection;
            // adcvec is copied, not moved: in case of compression, adcvec will show
            // less data: e.g. if the uncompressed adcvec has 9600 items, after
            // compression it will have maybe 5000, but the memory of the other 4600
            // is still there, although unused; a copy of adcvec will instead have
            // only 5000 items. All 9600 items of adcvec will be recovered for free
            // and used on the next loop.
            raw::RawDigit rd(channel, fNTimeSamples, adcvec, fCompression);

            if(fMakeHistograms && plane==2)
            {
                short area = std::accumulate(adcvec.begin(),adcvec.end(),0,[](const auto& val,const auto& sum){return sum + val - 400;});

                if(area>0)
                {
                    std::vector<geo::WireID> widVec = fGeometry.ChannelToWire(channel);

                    fSimCharge->Fill(area);
                    fSimChargeWire->Fill(widVec[0].Wire,area);
                }
            }

            rd.SetPedestal(ped_mean);
            digcol->push_back(std::move(rd)); // we do move the raw digit copy, though
        }

        boardCount++;
    }
    evt.put(std::move(digcol), fOutInstanceLabel);
    
    return;
}

void detsim::SimReadoutBoardICARUS::reconfigure

(

fhicl::ParameterSet const &

p

)

Definition at line 169 of file SimReadoutBoardICARUS_module.cc.

{
    fDriftEModuleLabel = p.get< art::InputTag       >("DriftEModuleLabel",             "largeant");
    fOutInstanceLabel  = p.get< std::string         >("OutputInstanceLabel",                   "");
    fProcessAllTPCs    = p.get< bool                >("ProcessAllTPCs",                     false);
    fCryostat          = p.get< unsigned int        >("Cryostat",                               0);
    fSimDeadChannels   = p.get< bool                >("SimDeadChannels",                    false);
    fSuppressNoSignal  = p.get< bool                >("SuppressNoSignal",                   false);
    fMakeHistograms    = p.get< bool                >("MakeHistograms",                     false);
    fSmearPedestals    = p.get< bool                >("SmearPedestals",                      true);
    fNumChanPerMB      = p.get< int                 >("NumChanPerMB",                          32);
    fTest              = p.get< bool                >("Test",                               false);
    fTestWire          = p.get< size_t              >("TestWire",                               0);
    fTestIndex         = p.get< std::vector<size_t> >("TestIndex",          std::vector<size_t>());
    fTestCharge        = p.get< std::vector<double> >("TestCharge",         std::vector<double>());

    using TPCValsPair = std::pair<unsigned int, unsigned int>; // Assume cryostat, TPC 
    using TPCValsVec  = std::vector<TPCValsPair>;

    TPCValsVec tempIDVec = p.get< TPCValsVec >("TPCVec", TPCValsVec());

    for(const auto& idPair : tempIDVec)
    {
        fTPCVec.push_back(geo::TPCID(idPair.first,idPair.second));
    }

    if(fTestIndex.size() != fTestCharge.size())
        throw cet::exception(__FUNCTION__)<<"# test pulse mismatched: check TestIndex and TestCharge fcl parameters...";
    
    fNoiseTool = art::make_tool<icarus_tool::IGenNoise>(p.get<fhicl::ParameterSet>("NoiseGenTool"));

    //Map the Shaping Times to the entry position for the noise ADC
    //level in fNoiseFactInd and fNoiseFactColl
    fShapingTimeOrder = { {0.6, 0}, {1, 1}, {1.3, 2}, {3.0, 3} };

    //detector properties information
    auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob();
    fNTimeSamples = detProp.NumberTimeSamples();
    
    fSignalShapingService = art::ServiceHandle<icarusutil::SignalShapingICARUSService>{}.get();

    fFFT = std::make_unique<icarus_signal_processing::ICARUSFFT<double>>(fNTimeSamples);
    
    return;
}

Member Data Documentation

const float detsim::SimReadoutBoardICARUS::adcsaturation = 4095

private

Definition at line 124 of file SimReadoutBoardICARUS_module.cc.

const icarusDB::IICARUSChannelMap* detsim::SimReadoutBoardICARUS::fChannelMap

private

Definition at line 143 of file SimReadoutBoardICARUS_module.cc.

raw::Compress_t detsim::SimReadoutBoardICARUS::fCompression

private

compression type to use

Definition at line 96 of file SimReadoutBoardICARUS_module.cc.

CLHEP::HepRandomEngine& detsim::SimReadoutBoardICARUS::fCorNoiseEngine

private

Definition at line 120 of file SimReadoutBoardICARUS_module.cc.

unsigned int detsim::SimReadoutBoardICARUS::fCryostat

private

If ProcessAllTPCs is false then cryostat to use.

Definition at line 94 of file SimReadoutBoardICARUS_module.cc.

art::InputTag detsim::SimReadoutBoardICARUS::fDriftEModuleLabel

private

module making the ionization electrons

Definition at line 91 of file SimReadoutBoardICARUS_module.cc.

FFTPointer detsim::SimReadoutBoardICARUS::fFFT

private

Definition at line 138 of file SimReadoutBoardICARUS_module.cc.

const geo::GeometryCore& detsim::SimReadoutBoardICARUS::fGeometry

private

Definition at line 141 of file SimReadoutBoardICARUS_module.cc.

bool detsim::SimReadoutBoardICARUS::fMakeHistograms

private

Definition at line 107 of file SimReadoutBoardICARUS_module.cc.

std::unique_ptr<icarus_tool::IGenNoise> detsim::SimReadoutBoardICARUS::fNoiseTool

private

Tool for generating noise.

Definition at line 105 of file SimReadoutBoardICARUS_module.cc.

unsigned int detsim::SimReadoutBoardICARUS::fNTimeSamples

private

number of ADC readout samples in all readout frames (per event)

Definition at line 97 of file SimReadoutBoardICARUS_module.cc.

int detsim::SimReadoutBoardICARUS::fNumChanPerMB

private

Number of channels per motherboard.

Definition at line 103 of file SimReadoutBoardICARUS_module.cc.

std::string detsim::SimReadoutBoardICARUS::fOutInstanceLabel

private

The label to apply to the output data product.

Definition at line 92 of file SimReadoutBoardICARUS_module.cc.

CLHEP::HepRandomEngine& detsim::SimReadoutBoardICARUS::fPedestalEngine

private

Definition at line 118 of file SimReadoutBoardICARUS_module.cc.

bool detsim::SimReadoutBoardICARUS::fProcessAllTPCs

private

If true we process all TPCs.

Definition at line 93 of file SimReadoutBoardICARUS_module.cc.

std::map< double, int > detsim::SimReadoutBoardICARUS::fShapingTimeOrder

private

Definition at line 98 of file SimReadoutBoardICARUS_module.cc.

icarusutil::SignalShapingICARUSService* detsim::SimReadoutBoardICARUS::fSignalShapingService

private

Definition at line 142 of file SimReadoutBoardICARUS_module.cc.

TH1F* detsim::SimReadoutBoardICARUS::fSimCharge

private

Definition at line 114 of file SimReadoutBoardICARUS_module.cc.

TH2F* detsim::SimReadoutBoardICARUS::fSimChargeWire

private

Definition at line 115 of file SimReadoutBoardICARUS_module.cc.

bool detsim::SimReadoutBoardICARUS::fSimDeadChannels

private

if True, simulate dead channels using the ChannelStatus service. If false, do not simulate dead channels

Definition at line 100 of file SimReadoutBoardICARUS_module.cc.

bool detsim::SimReadoutBoardICARUS::fSmearPedestals

private

If True then we smear the pedestals.

Definition at line 102 of file SimReadoutBoardICARUS_module.cc.

bool detsim::SimReadoutBoardICARUS::fSuppressNoSignal

private

If no signal on wire (simchannel) then suppress the channel.

Definition at line 101 of file SimReadoutBoardICARUS_module.cc.

bool detsim::SimReadoutBoardICARUS::fTest

private

Definition at line 108 of file SimReadoutBoardICARUS_module.cc.

std::vector<double> detsim::SimReadoutBoardICARUS::fTestCharge

private

Definition at line 112 of file SimReadoutBoardICARUS_module.cc.

std::vector<size_t> detsim::SimReadoutBoardICARUS::fTestIndex

private

Definition at line 111 of file SimReadoutBoardICARUS_module.cc.

std::vector<sim::SimChannel> detsim::SimReadoutBoardICARUS::fTestSimChannel_v

private

Definition at line 109 of file SimReadoutBoardICARUS_module.cc.

size_t detsim::SimReadoutBoardICARUS::fTestWire

private

Definition at line 110 of file SimReadoutBoardICARUS_module.cc.

TPCIDVec detsim::SimReadoutBoardICARUS::fTPCVec

private

List of TPCs to process for this instance of the module.

Definition at line 95 of file SimReadoutBoardICARUS_module.cc.

CLHEP::HepRandomEngine& detsim::SimReadoutBoardICARUS::fUncNoiseEngine

private

Definition at line 119 of file SimReadoutBoardICARUS_module.cc.

---

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

• SimReadoutBoardICARUS_module.cc