FrontEnd.cc

Go to the documentation of this file.

#include <mdet/FrontEnd.h>

#include <mdet/Pixel.h>
#include <mdet/MHierarchyInfo.h>

#include <sstream>
#include <iostream>
#include <bitset> 
#include <iomanip>

namespace mdet {

  const char* const 
  FrontEnd::kComponentName = MHierarchyInfo::kComponentsNames[2];

  const char* const  
  FrontEnd::kComponentId   = MHierarchyInfo::kComponentsIds[2];

  FrontEnd::FrontEnd
    (int fId, const det::VManager::IndexMap& parentMap, const Module& parent) :
      MDetectorComponent<FrontEnd>::Type(fId, parentMap),
      fChannels(*this),
      fModule(parent)
  {
    Register(fMeanSampleRatePeriod);
    Register(fSampleRatePeriodJitter);
    Register(fPreT1BufferLength);
    Register(fPostT1BufferLength);
    Register(fExternalMemoryBufferLength);
    Register(fTrueRangeLowThreshold);
    Register(fFalseRangeHiThreshold);
    fChannels.Update(GetIdsMap());
  }

  const Module&
  FrontEnd::GetModule()
    const
  {
    return fModule;
  }
  
  double 
  FrontEnd::GetMeanSampleRatePeriod() 
    const 
  {
    return GetData(fMeanSampleRatePeriod, "meanSampleRatePeriod");
  }

  double 
  FrontEnd::GetSampleRatePeriodJitter() 
    const
  {
    return GetData(fSampleRatePeriodJitter, "sampleRatePeriodJitter");
  }

  unsigned int 
  FrontEnd::GetPreT1BufferLength() 
    const 
  {
    // See field declaration: there's a signed to unsigned conversion.
    return GetData(fPreT1BufferLength, "preT1BufferLength");
  }

  unsigned int 
  FrontEnd::GetPostT1BufferLength() 
    const
  {
    // See GetPreT1BufferLength
    return GetData(fPostT1BufferLength, "postT1BufferLength");
  }
/*
  unsigned int 
  FrontEnd::GetExternalMemoryBufferLength() 
    const
  {
    // See GetPreT1BufferLength
    return GetData(fExternalMemoryBufferLength, "externalMemoryBufferLength");
  }
*/
  double 
  FrontEnd::GetTrueRangeLowThreshold() 
    const
  {
    return GetData(fTrueRangeLowThreshold, "trueRangeLowThreshold");
  }
  
  double 
  FrontEnd::GetFalseRangeHiThreshold() 
    const
  {
    return GetData(fFalseRangeHiThreshold, "falseRangeHiThreshold");
  }

  const FrontEnd::BrokenChannelContainer&
  FrontEnd::GetBrokenChannels()
    const 
  {
    // Note that's shared: so once initialized no further loading
    // will be done. 
    return GetData<BrokenChannelContainer,utl::ThrowOnZeroDereference,utl::ShadowPtr>(fBrokenChannels, "channelsBroken");
  }

  ULong64_t
  FrontEnd::GetMask() 
    const 
  {
    std::ostringstream msg;

    ULong64_t mask = 0;

    std::bitset<64> bit_mask;
    bit_mask.reset();//sets all bits to zero

    msg.str("");
    const BrokenChannelContainer * channels = 0;
    channels = & GetBrokenChannels();

    for ( BrokenChannelContainer::const_iterator chIt = channels->begin(), chIte = channels->end();
            chIt != chIte; ++chIt ){
       msg << *chIt << " " ;   
       bit_mask.set(*chIt);//set channel X to one
       mask |= ULong64_t(1) << *chIt;
    }
    msg << std::endl;

    msg << "MD MASK  -- " << std::setw( 10 ) << std::setfill(' ')
         << bit_mask << " "
         << " ==> (" << bit_mask.count() << ")\n";
    msg  << "mask in decimal: " << std::endl;
    msg  << mask <<  std::endl;

    return mask;
  }


 
  FrontEnd::Sampler 
  FrontEnd::MakeSampler() 
    const
  {
    return Sampler(*this);
  }
  
  FrontEnd::Sampler::Sampler(const FrontEnd& fe) :
    fLastSample(false), // Take as false the non-existing previous sample
    fFrontEnd(fe)
  {
  }

  bool 
  FrontEnd::Sampler::operator()(double v)
  {
    // Note that we use both comps with =, tough, if both
    // limits coincide, we are privileging one of them 
    // (the first we are comparing with).
    bool ret;
    if (v >= fFrontEnd.GetTrueRangeLowThreshold())
      ret = true;
    else if (v <= fFrontEnd.GetFalseRangeHiThreshold())
      ret = false;
    else 
      ret = fLastSample;
    // Keep this as the new last sample.
    fLastSample = ret;
    return ret;
  }

  void
  FrontEnd::Update(bool invalidateData, bool invalidateComponents)
  {
    MDetectorComponent<FrontEnd>::Type::Update(invalidateData, invalidateComponents);
    fChannels.Update(GetIdsMap(), invalidateData, invalidateComponents);
    if ( invalidateData ) 
      fBrokenChannels = 0;  
  }

}