#include <DigitizerFP420.h>

Inheritance diagram for cms::DigitizerFP420:

Public Member Functions
	DigitizerFP420 (const edm::ParameterSet &conf)

void	produce (edm::Event &e, const edm::EventSetup &c) override

	~DigitizerFP420 () override

Public Member Functions inherited from edm::one::EDProducer<>
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Types
typedef std::map< unsigned int, std::vector< PSimHit >, std::less< unsigned int > >	simhit_map

typedef simhit_map::iterator	simhit_map_iterator

typedef std::vector< std::string >	vstring

Private Attributes
std::vector< HDigiFP420 >	collector

edm::ParameterSet	conf_

int	dn0

int	numStrips

int	pn0

int	rn0

simhit_map	SimHitMap

int	sn0

FP420DigiMain *	stripDigitizer_

vstring	trackerContainers

int	verbosity

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 32 of file DigitizerFP420.h.

Member Typedef Documentation

typedef std::map<unsigned int, std::vector<PSimHit>, std::less<unsigned int> > cms::DigitizerFP420::simhit_map

private

Definition at line 42 of file DigitizerFP420.h.

typedef simhit_map::iterator cms::DigitizerFP420::simhit_map_iterator

private

Definition at line 43 of file DigitizerFP420.h.

typedef std::vector<std::string> cms::DigitizerFP420::vstring

private

Definition at line 41 of file DigitizerFP420.h.

Constructor & Destructor Documentation

cms::DigitizerFP420::DigitizerFP420 ( const edm::ParameterSet & conf )

explicit

Definition at line 62 of file DigitizerFP420.cc.

References egammaCTFFinalFitWithMaterial_cff::alias, conf_, gather_cfg::cout, dn0, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), pn0, rn0, sn0, AlCaHLTBitMon_QueryRunRegistry::string, trackerContainers, and verbosity.

       : conf_(conf), stripDigitizer_(new FP420DigiMain(conf)) {
     std::string alias(conf.getParameter<std::string>("@module_label"));
 
     //  produces<edm::DetSetVector<HDigiFP420> >().setBranchAlias( alias );
     //  produces<edm::DetSetVector<HDigiFP420SimLink> >().setBranchAlias ( alias +
     //  "hDigiFP420SimLink");
     produces<DigiCollectionFP420>().setBranchAlias(alias);
 
     trackerContainers.clear();
     trackerContainers = conf.getParameter<std::vector<std::string>>("ROUList");
 
     verbosity = conf_.getUntrackedParameter<int>("VerbosityLevel");
     dn0 = conf_.getParameter<int>("NumberFP420Detectors");
     sn0 = conf_.getParameter<int>("NumberFP420Stations");
     pn0 = conf_.getParameter<int>("NumberFP420SPlanes");
     rn0 = 7;
     // rn0 = 3;
 
     //  produces<DigiCollectionFP420>();
 
     //  produces<StripDigiCollection>();
     //   produces<HDigiFP420>();
     //  produces<edm::DetSetVector<HDigiFP420> >().setBranchAlias( alias );
 
     //  produces<DigiCollectionFP420>();
     // produces<DigiCollectionFP420>("HDigiFP420");
 
     //  produces<edm::DigiCollectionFP420>();
 
     //   produces<edm::DetSetVector<DigiCollectionFP420> >();
 
     if (verbosity > 0) {
       std::cout << "Creating a DigitizerFP420" << std::endl;
       std::cout << "DigitizerFP420: dn0=" << dn0 << " sn0=" << sn0 << " pn0=" << pn0 << " rn0=" << rn0 << std::endl;
       std::cout << "DigitizerFP420:trackerContainers.size()=" << trackerContainers.size() << std::endl;
     }
   }

cms::DigitizerFP420::~DigitizerFP420 ( )

override

Definition at line 102 of file DigitizerFP420.cc.

References gather_cfg::cout, stripDigitizer_, and verbosity.

                                   {
     if (verbosity > 0) {
       std::cout << "Destroying a DigitizerFP420" << std::endl;
     }
     delete stripDigitizer_;
   }

Member Function Documentation

void cms::DigitizerFP420::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Definition at line 110 of file DigitizerFP420.cc.

References HDigiFP420::adc(), HDigiFP420::channel(), collector, gather_cfg::cout, PSimHit::detUnitId(), dn0, plotBeamSpotDB::first, edm::Event::getByLabel(), mps_fire::i, estimatePileup::inputRange, eostools::move(), convertSQLitetoXML_cfg::output, FP420NumberingScheme::packFP420Index(), FP420NumberingScheme::packMYIndex(), pn0, edm::Handle< T >::product(), edm::Event::put(), rn0, FP420DigiMain::run(), SimHitMap, sn0, HDigiFP420::strip(), stripDigitizer_, HDigiFP420::stripV(), HDigiFP420::stripVW(), trackerContainers, FP420NumberingScheme::unpackFP420Index(), FP420NumberingScheme::unpackLayerIndex(), FP420NumberingScheme::unpackMYIndex(), FP420NumberingScheme::unpackOrientation(), verbosity, and ecaldqm::zside().

                                                                             {
     // be lazy and include the appropriate namespaces
     using namespace edm;
     using namespace std;
 
     if (verbosity > 0) {
       std::cout << " ===" << std::endl;
       std::cout << " ============== DigitizerFP420: start   produce= " << std::endl;
       std::cout << " ===" << std::endl;
     }
     // Get input
     //    std::cout << "DigitizerFP420 start produce" << std::endl;
     //  edm::ESHandle < ParticleDataTable > pdt;
     //  iSetup.getData( pdt );
 
     // Step A: Get Inputs for allTrackerHits
 
     edm::Handle<CrossingFrame<PSimHit>> cf_simhit;
     std::vector<const CrossingFrame<PSimHit> *> cf_simhitvec;
     for (uint32_t i = 0; i < trackerContainers.size(); i++) {
       iEvent.getByLabel("mix", trackerContainers[i], cf_simhit);
       cf_simhitvec.push_back(cf_simhit.product());
     }
     std::unique_ptr<MixCollection<PSimHit>> allTrackerHits(new MixCollection<PSimHit>(cf_simhitvec));
 
     // use instead of the previous
     /*
         std::cout <<" ============== DigitizerFP420: start loop           1   "
      << std::endl; edm::Handle<CrossingFrame<PSimHit> > xFrame; std::cout <<"
      ============== DigitizerFP420: start loop           2   " << std::endl;
         iEvent.getByLabel("mix","FP420SI",xFrame);
         std::cout <<" ============== DigitizerFP420: start loop           3   "
      << std::endl; std::unique_ptr<MixCollection<PSimHit> > allTrackerHits( new
      MixCollection<PSimHit>(xFrame.product()) ); std::cout <<" ==============
      DigitizerFP420: start loop           4   " << std::endl;
   */
 
     // Loop on PSimHit
 
     // Step C: create empty output collection
     std::unique_ptr<DigiCollectionFP420> output(new DigiCollectionFP420);
     //  std::unique_ptr<edm::DetSetVector<HDigiFP420> > outputfinal(new
     //  edm::DetSetVector<HDigiFP420>(output) );
     //  std::unique_ptr<edm::DetSetVector<HDigiFP420> > outputfinal(new
     //  edm::DetSetVector<HDigiFP420>(output) );
     //  std::unique_ptr<edm::DetSetVector<HDigiFP420SimLink> > outputlink(new
     //  edm::DetSetVector<HDigiFP420SimLink>(output) );
 
     SimHitMap.clear();
 
     // ==================================
     if (verbosity > 0) {
       std::cout << " ===" << std::endl;
       std::cout << " ============== DigitizerFP420: MixCollection treatment= " << std::endl;
       std::cout << " ===" << std::endl;
     }
 
     MixCollection<PSimHit>::iterator isim;
     for (isim = allTrackerHits->begin(); isim != allTrackerHits->end(); isim++) {
       unsigned int unitID = (*isim).detUnitId();
       int det, zside, sector, zmodule;
       FP420NumberingScheme::unpackFP420Index(unitID, det, zside, sector, zmodule);
       // below, the continues plane index should be (for even different sensor
       // index zside)
       //    unsigned int intindex = packMYIndex(rn0, pn0, sn0, det, zside, sector,
       // zmodule);
       unsigned int intindex = FP420NumberingScheme::packMYIndex(rn0, pn0, sn0, det, zside, sector, zmodule);
       //    int zScale=(rn0-1), sScale = (rn0-1)*(pn0-1), dScale =
       //(rn0-1)*(pn0-1)*(sn0-1);    unsigned int intindex = dScale*(det -
       // 1)+sScale*(sector - 1)+zScale*(zmodule - 1)+zside;
 
       if (verbosity > 0) {
         double losenergy = (*isim).energyLoss();
         std::cout << " ===" << std::endl;
         std::cout << " ============== DigitizerFP420:  losenergy= " << losenergy << std::endl;
         std::cout << " === for intindex = " << intindex << std::endl;
       }
       // does not matter which index is used: intindex or unitID - mainly to
       // collect hits under every index
       SimHitMap[intindex].push_back((*isim));
       // for development later one( cal be used another index):
       //    SimHitMap[unitID].push_back((*isim));
     }
     //============================================================================================================================
 
     if (verbosity > 0) {
       std::cout << " ===" << std::endl;
       std::cout << " ============== DigitizerFP420: put zero to container " << std::endl;
       std::cout << " ===" << std::endl;
     }
     //    put zero to container info from the beginning (important! because not
     //    any detID is updated with coming of new event     !!!!!!
     // clean info of container from previous event
     for (int det = 1; det < dn0; det++) {
       for (int sector = 1; sector < sn0; sector++) {
         for (int zmodule = 1; zmodule < pn0; zmodule++) {
           for (int zside = 1; zside < rn0; zside++) {
             // intindex is a continues numbering of FP420
             unsigned int detID = FP420NumberingScheme::packMYIndex(rn0, pn0, sn0, det, zside, sector, zmodule);
             // int zScale=(rn0-1), sScale = (rn0-1)*(pn0-1), dScale =
             // (rn0-1)*(pn0-1)*(sn0-1); unsigned int detID = dScale*(det -
             // 1)+sScale*(sector - 1)+zScale*(zmodule - 1)+zside;
             std::vector<HDigiFP420> collector;
             collector.clear();
             DigiCollectionFP420::Range inputRange;
             inputRange.first = collector.begin();
             inputRange.second = collector.end();
             output->putclear(inputRange, detID);
           }  // for
         }    // for
       }      // for
     }        // for
     //                                                                                                                      !!!!!!
     // if we want to keep Digi container/Collection for one event uncomment the
     // line below and vice versa
     output->clear();  // container_.clear() --> start from the beginning of the
                       // container
 
     //============================================================================================================================================
 
     if (verbosity > 0) {
       std::cout << " ===" << std::endl;
       std::cout << " ============== DigitizerFP420: start loop over det iu " << std::endl;
       std::cout << " ============== DigitizerFP420: SimHitMap.size()= " << SimHitMap.size() << std::endl;
       std::cout << " ===" << std::endl;
     }
     bool first = true;
 
     /*
   if(verbosity>0) std::cout <<"=======  DigitizerFP420:  SimHitMap size = " <<
   SimHitMap.size() << std::endl; for(unsigned int i = 0; i < SimHitMap.size();
   i++ ) {
     //    std::cout <<" ====== DigitizerFP420: i= " << i << std::endl;
     vector<PSimHit>::const_iterator simHitIter = SimHitMap[i].begin();
     vector<PSimHit>::const_iterator simHitIterEnd = SimHitMap[i].end();
     for (;simHitIter != simHitIterEnd; ++simHitIter) {
       const PSimHit ihit = *simHitIter;
       unsigned int unitID = ihit.detUnitId();
       if(verbosity>0) std::cout <<" ====== DigitizerFP420: unitID= " << unitID
   << " i=  " << i << std::endl; int det, zside, sector, zmodule;
       FP420NumberingScheme::unpackFP420Index(unitID, det, zside, sector,
   zmodule); int zScale=(rn0-1), sScale = (rn0-1)*(pn0-1), dScale =
   (rn0-1)*(pn0-1)*(sn0-1); unsigned int iu = dScale*(det - 1)+sScale*(sector -
   1)+zScale*(zmodule - 1)+zside;
     }
   }
 */
     //============================================================================================================================================
     // new:   <------
     for (unsigned int i = 0; i < SimHitMap.size(); i++) {
       vector<PSimHit>::const_iterator simHitIter = SimHitMap[i].begin();
       vector<PSimHit>::const_iterator simHitIterEnd = SimHitMap[i].end();
       for (; simHitIter != simHitIterEnd; ++simHitIter) {
         const PSimHit ihit = *simHitIter;
         unsigned int unitID = ihit.detUnitId();
         if (verbosity > 0 || verbosity == -50)
           std::cout << " ====== DigitizerFP420: unitID= " << unitID << "Hit number i=  " << i << std::endl;
         int det, zside, sector, zmodule;
         FP420NumberingScheme::unpackFP420Index(unitID, det, zside, sector, zmodule);
 
         unsigned int iu = FP420NumberingScheme::packMYIndex(rn0, pn0, sn0, det, zside, sector, zmodule);
         if (verbosity > 0 || verbosity == -50)
           std::cout << "for Hits iu = " << iu << " sector = " << sector << " zmodule = " << zmodule
                     << " zside = " << zside << "  det=" << det << std::endl;
         //   int zScale=(rn0-1), sScale = (rn0-1)*(pn0-1), dScale =
         //   (rn0-1)*(pn0-1)*(sn0-1);
         //  unsigned int iu = dScale*(det - 1)+sScale*(sector - 1)+zScale*(zmodule
         //  - 1)+zside;
 
         if (verbosity > 0) {
           unsigned int index = FP420NumberingScheme::packFP420Index(det, zside, sector, zmodule);
           std::cout << " DigitizerFP420:       index = " << index << " iu = " << iu << std::endl;
         }
 
         //    GlobalVector bfield=pSetup->inTesla((*iu)->surface().position());
         //      CLHEP::Hep3Vector Bfieldloc=bfield();
         G4ThreeVector bfield(0., 0., 0.0);
         //  G4ThreeVector bfield(  0.5,  0.5,  1.0  );
 
         if (verbosity > 0) {
           std::cout << " ===" << std::endl;
           std::cout << " ============== DigitizerFP420:  call run for iu= " << iu << std::endl;
           std::cout << " ===" << std::endl;
         }
         collector.clear();
 
         collector = stripDigitizer_->run(SimHitMap[iu], bfield,
                                          iu);  // stripDigitizer_.run...  return
         //                       ,sScale
 
         if (verbosity > 0) {
           std::cout << " ===" << std::endl;
           std::cout << " ===" << std::endl;
           std::cout << "=======  DigitizerFP420:  collector size = " << collector.size() << std::endl;
           std::cout << " ===" << std::endl;
           std::cout << " ===" << std::endl;
         }
         /*
 
       std::vector<HDigiFP420> collector;
       collector.clear();
       DigiCollectionFP420::Range inputRange;
       inputRange.first = collector.begin();
       inputRange.second = collector.end();
       output->putclear(inputRange,detID);
       */
         if (!collector.empty()) {
           if (verbosity > 0) {
             std::cout << "         ============= DigitizerFP420:collector "
                          "start!!!!!!!!!!!!!!"
                       << std::endl;
           }
           DigiCollectionFP420::Range outputRange;
           outputRange.first = collector.begin();
           outputRange.second = collector.end();
 
           if (first) {
             // use it only if ClusterCollectionFP420 is the ClusterCollection of
             // one event, otherwise, do not use (loose 1st cl. of 1st event only)
             first = false;
             unsigned int detID0 = 0;
             output->put(outputRange, detID0);  // !!! put into adress 0 for detID
                                                // which will not be used never
           }                                    // if ( first )
 
           // put !!!
           output->put(outputRange, iu);
 
         }  // if(collector.size()>0
 
         //   }   // for
         // }   // for
         //  }   // for
         // }   // for
 
       }  // for
     }    // for
 
     // END
 
     /*
   if(verbosity>0) {
     std::vector<HDigiFP420> theAllDigis;
     theAllDigis.clear();
     DigiCollectionFP420::Range outputRange;
     DigiCollectionFP420::ContainerIterator sort_begin = outputRange.first;
     DigiCollectionFP420::ContainerIterator sort_end = outputRange.second;
     theAllDigis.insert(theAllDigis.end(), sort_begin, sort_end);
     std::cout <<"======  theAllDigis size = " << theAllDigis.size() <<
   std::endl; for (std::vector<HDigiFP420>::iterator isim = theAllDigis.begin();
          isim != theAllDigis.end(); ++isim){
       const HDigiFP420 istrip = *isim;
       std::cout <<
   "*******************************************DigitizerFP420:check1" <<
   std::endl; std::cout << " strip number=" << istrip.strip() << "  adc=" <<
   istrip.adc() << std::endl; std::cout <<" channel =" << istrip.channel() <<" V
   " << istrip.stripV() <<" VW " << istrip.stripVW() << std::endl; std::cout <<"
   ===" << std::endl; std::cout <<" ===" << std::endl; std::cout <<"
   =======================" << std::endl;
     }// for
   }
 */
     if (verbosity == -50) {
       //     check of access to the collector:
       for (int det = 1; det < dn0; det++) {
         for (int sector = 1; sector < sn0; sector++) {
           for (int zmodule = 1; zmodule < pn0; zmodule++) {
             for (int zside = 1; zside < rn0; zside++) {
               unsigned int iu = FP420NumberingScheme::packMYIndex(rn0, pn0, sn0, det, zside, sector, zmodule);
               int layer = FP420NumberingScheme::unpackLayerIndex(rn0, zside);
               int orient = FP420NumberingScheme::unpackOrientation(rn0, zside);
               std::cout << "****DigitizerFP420:check2" << std::endl;
               //    std::cout <<" iu = " << iu <<" sector = " << sector <<" zmodule
               //= " << zmodule <<" zside = " << zside << "  det=" << det <<
               // std::endl;     std::cout <<" layer = " << layer <<" orient = "
               // << orient << std::endl;
               int newdet, newzside, newsector, newzmodule;
               FP420NumberingScheme::unpackMYIndex(iu, rn0, pn0, sn0, newdet, newzside, newsector, newzmodule);
               std::cout << " newdet = " << newdet << " newsector = " << newsector << " newzmodule = " << newzmodule
                         << " newzside = " << newzside << std::endl;
 
               collector.clear();
               DigiCollectionFP420::Range outputRange;
               //    outputRange = output->get(iu);
               outputRange = output->get(iu);
 
               // fill output in collector vector (for may be sorting? or other
               // checks)
               std::vector<HDigiFP420> collector;
               //  collector.clear();
               DigiCollectionFP420::ContainerIterator sort_begin = outputRange.first;
               DigiCollectionFP420::ContainerIterator sort_end = outputRange.second;
               for (; sort_begin != sort_end; ++sort_begin) {
                 collector.push_back(*sort_begin);
               }  // for
               //  std::sort(collector.begin(),collector.end());
               std::cout << " ===" << std::endl;
               std::cout << "======  collector size = " << collector.size() << std::endl;
               if (!collector.empty()) {
                 std::cout << " iu = " << iu << " sector = " << sector << " zmodule = " << zmodule
                           << " zside = " << zside << "  det=" << det << " layer = " << layer << " orient = " << orient
                           << std::endl;
                 std::cout << " ===" << std::endl;
               }
               vector<HDigiFP420>::const_iterator simHitIter = collector.begin();
               vector<HDigiFP420>::const_iterator simHitIterEnd = collector.end();
               for (; simHitIter != simHitIterEnd; ++simHitIter) {
                 const HDigiFP420 istrip = *simHitIter;
                 std::cout << " strip number=" << istrip.strip() << "  adc=" << istrip.adc() << std::endl;
                 std::cout << " channel =" << istrip.channel() << " V " << istrip.stripV() << " VW " << istrip.stripVW()
                           << std::endl;
                 std::cout << " ===" << std::endl;
                 std::cout << " ===" << std::endl;
                 std::cout << " ===================================================" << std::endl;
               }
 
               //==================================
 
             }  // for
           }    // for
         }      // for
       }        // for
 
       //     end of check of access to the strip collection
 
     }  // if(verbosity
 
     // Step D: write output to file
     if (verbosity > 0) {
       std::cout << "DigitizerFP420 recoutput" << std::endl;
     }
     // Step D: write output to file
     iEvent.put(std::move(output));
   }  // produce