HardwareMapperService Class Reference

#include <HardwareMapperService.h>

Public Member Functions
	HardwareMapperService (fhicl::ParameterSet const &pset, art::ActivityRegistry &reg)
void	printASICMap (unsigned int num_asics_to_print=20)
void	printBoardMap (unsigned int num_boards_to_print=20)
void	printTPCMap (unsigned int num_tpcs_to_print=20)
void	printAPAMap (unsigned int num_apas_to_print=20)
void	printHardwareMaps ()
void	printGeometryInfo ()
unsigned int	getNASICs () const
unsigned int	getNBoards () const
unsigned int	getNAPAs () const
unsigned int	getNTPCs () const
std::vector< raw::ChannelID_t > const &	getTPCChannels (Hardware::ID tpc_id)
std::vector< raw::ChannelID_t > const &	getAPAChannels (Hardware::ID apa_id)
std::set< raw::ChannelID_t > const &	getTPCChannelsSet (Hardware::ID tpc_id)
std::set< raw::ChannelID_t > const &	getAPAChannelsSet (Hardware::ID apa_id)
void	checkGeomVsFileDetectorName (art::Run const &run)

Private Member Functions
void	fillASICMap ()
void	fillBoardMap ()
void	fillTPCMap ()
void	fillAPAMap ()
void	fillHardwareMaps ()

Private Attributes
unsigned int	fLogLevel
unsigned int	fNASICsPerBoard
unsigned int	fNBoardsPerAPA
std::string	fServiceName
art::ServiceHandle< geo::Geometry >	fGeometryService
std::string	fDetectorNameFromGeometry
std::string	fDetectorNameFromFile
Hardware::ASICMap	fASICMap
Hardware::BoardMap	fBoardMap
Hardware::TPCMap	fTPCMap
Hardware::APAMap	fAPAMap

Detailed Description

Definition at line 40 of file HardwareMapperService.h.

Constructor & Destructor Documentation

HardwareMapperService::HardwareMapperService	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &	reg
	)

Definition at line 18 of file HardwareMapperService_service.cc.

  : fLogLevel(1), fNASICsPerBoard(1), fNBoardsPerAPA(1), fServiceName("HardwareMapperService") {
  pset.get_if_present<unsigned int>("LogLevel", fLogLevel);
  pset.get_if_present<unsigned int>("NASICsPerBoard", fNASICsPerBoard);
  pset.get_if_present<unsigned int>("NBoardsPerAPA", fNBoardsPerAPA);
  const std::string func_name = "HardwareMapperService";
  {
    mf::LogInfo loginfo(fServiceName);
    loginfo << func_name << "\n"
            << "fLogLevel: " << fLogLevel << "\n"
            << "fNASICsPerBoard: " << fNASICsPerBoard << "\n"
            << "fNBoardsPerAPA: " << fNBoardsPerAPA;
  }
  //jpd -- This is how to register a callback function to the activity registry
  //    -- This means that upon the preBeginRun (which I assume is immediately before
  //    -- begin run) this function (HardwareMapperService::preBeginRun) will be called

  reg.sPreBeginRun.watch(this, &HardwareMapperService::checkGeomVsFileDetectorName);
  fillHardwareMaps();
}

Member Function Documentation

void HardwareMapperService::checkGeomVsFileDetectorName

(

art::Run const &

run

)

Definition at line 40 of file HardwareMapperService_service.cc.

                                                                        {
  const std::string func_name = "checkGeomVsFileDetectorName";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;

  //jpd -- Check that the Detector Name matches between the Geometry and the File
  //Inspired by Geometry_service.cc
  mf::LogInfo loginfo(fServiceName);

  auto const rdcol = run.getMany<sumdata::RunData>();
  if (rdcol.empty()) {
    mf::LogError(fServiceName) << "Can't find sumdata::RunData for geometry vs. file detector name checks";
    return;
  }

  fDetectorNameFromFile = rdcol.front()->DetName();

  loginfo << "This file has the following detector name:   " <<  fDetectorNameFromFile     << "\n";
  loginfo << "The geometry service has this detector name: " <<  fDetectorNameFromGeometry << "\n";
  
  if(fDetectorNameFromGeometry != fDetectorNameFromFile){
    throw cet::exception("HardwareMapperService") << "Detector Name missmatch!\n"
                                                  << "Detector Name from Geometry Service: " << fDetectorNameFromGeometry << "\n"
                                                  << "Detector Name from File: " << fDetectorNameFromFile << "\n"
                                                  << "This means that the HardwareMapperService is filled with information for the wrong Geometry\n"
                                                  << "Throwing an exception as the user should make sure the Geometry in their fcl and that used to produce their file match\n";
  }
}

void HardwareMapperService::fillAPAMap ( )

private

Definition at line 325 of file HardwareMapperService_service.cc.

                                      {
  const std::string func_name = "fillAPAMap";

  mf::LogInfo loginfo(fServiceName);
  if(fLogLevel>1)  loginfo << "In Function: " << func_name << "\n";

  unsigned int Nchannels   = fGeometryService->Nchannels();
  loginfo  << "Filling APA Map with " << Nchannels << " channels" << "\n";

  for(raw::ChannelID_t channel=0; channel<Nchannels ;channel++){
    std::vector<geo::WireID> const Wires = fGeometryService->ChannelToWire(channel);
    for(auto wire : Wires){
      auto apa_id = wire.TPC / 2;
      //jpd -- See if we have already created a APA object for this apa_id in our map
      auto find_result = fAPAMap.find(apa_id);
      std::shared_ptr<Hardware::APA> this_apa;
      if(find_result != fAPAMap.end()){
        //jpd -- We already have one, add this channel
        this_apa = (*find_result).second;
      }
      else{
        //jpd -- We don't have one. Create a new one and add this channel
        this_apa = std::shared_ptr<Hardware::APA>(new Hardware::APA(apa_id));
      }
      this_apa->addChannel(channel);
      fAPAMap[apa_id] = this_apa;
    }//loop over wires
  }//loop over channels
  loginfo  << "Finished filling APA Map\n"
           << "Filled: " << getNAPAs() << " APAs";
}

void HardwareMapperService::fillASICMap ( )

private

Definition at line 69 of file HardwareMapperService_service.cc.

                                       {
  const std::string func_name = "fillASICMap";

  mf::LogInfo loginfo(fServiceName);

  if(fLogLevel>1||true) loginfo << "In Function: " << func_name << "\n";//FIXME

  loginfo << "Filling ASIC Map - fNASICsPerBoard: " << fNASICsPerBoard << "\n";

  if(fLogLevel>0) loginfo << "Looping over Boards" << "\n";

  Hardware::ID current_asic_id = 0;
  for(auto id_board_pair: fBoardMap){
    std::shared_ptr<Hardware::Board> board_ptr = id_board_pair.second;
    
    if(fLogLevel>0) loginfo << *board_ptr << "\n";
    
    unsigned int channels_in_this_asic = 0;
    unsigned int max_channels_in_asic = board_ptr->getNChannels() / fNASICsPerBoard;
    
    if(fLogLevel>1) loginfo << "current_asic_id: " << current_asic_id << "\n";
    
    board_ptr->addHardwareID(Hardware::ASIC(current_asic_id));
    std::shared_ptr<Hardware::ASIC> this_asic_ptr = std::shared_ptr<Hardware::ASIC>(new Hardware::ASIC(current_asic_id));
    
    if(fLogLevel>1) loginfo << "Creating new asic" 
                            << " registered to Board: " << board_ptr->getID()
                            << "- This Board has: " << board_ptr->getNHardwareIDs()
                            << " pieces of hardware" 
                            << "\n\n";
    
    if(fLogLevel>1) loginfo << "Looping over channels" << "\n";
    
    for(auto channel : board_ptr->getChannels()){
      if(channels_in_this_asic >= max_channels_in_asic){
        if(fLogLevel>1) loginfo << "Need new asic - current_asic_id: " << current_asic_id
                                << " channels_in_this_asic: " << channels_in_this_asic
                                << "/" << max_channels_in_asic
                                << "\n";
        
        
        fASICMap[this_asic_ptr->getID()] = this_asic_ptr;
        current_asic_id++;
        channels_in_this_asic=0;
        
        if(fLogLevel>1) loginfo << "Last ASIC: " << *this_asic_ptr << "\n\n";
        
        this_asic_ptr=std::shared_ptr<Hardware::ASIC>(new Hardware::ASIC(current_asic_id));
        
        board_ptr->addHardwareID(Hardware::ASIC(current_asic_id));
        if(fLogLevel>1) loginfo << "Creating new asic" 
                                << " registered to Board: " << board_ptr->getID()
                                << "- This Board has: " << board_ptr->getNHardwareIDs()
                                << " pieces of hardware" 
                                << "\n\n";
      }
      this_asic_ptr->addChannel(channel);
      channels_in_this_asic++;
      
    }//channel in this board
    if(fLogLevel>1) loginfo << "Finished channel loop\n"
                            << "current_asic_id: " << current_asic_id
                            << " channels_in_this_asic: " << channels_in_this_asic
                            << "/" << max_channels_in_asic
                            << "\n";
    fASICMap[this_asic_ptr->getID()] = this_asic_ptr;
    current_asic_id++;//start each Board with a new ASIC 
    if(fLogLevel>0) loginfo << "Finished this Board\n"
                            << *board_ptr << "\n"
                            << "Total ASICs in fASICMap: " << getNASICs() << "\n"
                            << "-----------------------\n\n";
  }//id_board_pair;
  loginfo << "Finished filling ASIC Map\n"
          << "Filled: " << getNASICs() << " ASICs";
  
  
}

void HardwareMapperService::fillBoardMap ( )

private

Definition at line 148 of file HardwareMapperService_service.cc.

                                        {
 const std::string func_name = "fillBoardMap";
  if(fLogLevel>1||true) mf::LogInfo(fServiceName) << "In Function: " << func_name;//FIXME

  mf::LogInfo loginfo(fServiceName);
  loginfo << "Filling Board Map - fNBoardsPerAPA: " << fNBoardsPerAPA << "\n";

  Hardware::ID current_board_id = 0;
  if(fLogLevel>0) loginfo << "Looping over apas" << "\n";

  // --- Lets loop over the APA map
  for(auto id_apa_pair: fAPAMap){
    // --- Get a handle to this APA object.
    std::shared_ptr<Hardware::APA> apa_ptr = id_apa_pair.second;
    // --- How many channels should there be per board? 
    unsigned int max_channels_in_board = apa_ptr->getNChannels() / fNBoardsPerAPA;

    // Karl::Added to only run on the first APA.
    //if (apa_ptr->getID() > 1) continue;

    // --- Record the id of the current board that we are on.
    Hardware::ID FirstBoard  = current_board_id;
    // --- Make an array of boards for this APA, and then create them.
    std::vector< std::shared_ptr<Hardware::Board> > BoardsFromAPA;
    std::vector< TVector3 >      ZPosOfColWires;
    for (unsigned int cb=0; cb<fNBoardsPerAPA; ++cb) {
      // --- Add a board object to this APA
      apa_ptr->addHardwareID(Hardware::Board( current_board_id ));
      // --- Push back objects to my vectors.
      BoardsFromAPA .push_back( std::shared_ptr<Hardware::Board>(new Hardware::Board( current_board_id )) );
      ZPosOfColWires.push_back( {DBL_MAX, -DBL_MAX, -1} ); 
      std::cout << "Creating a new board with id " << FirstBoard+cb << " - " << BoardsFromAPA[ cb ]->getID() << " on APA " << apa_ptr->getID() << std::endl;
      // --- Incremment the current_board_id number.
      ++current_board_id;
    }
    
    // --- Now that I have a vector of boards for this APA, lets loop over the channels on this APA and assign them to each board! 
    if(fLogLevel>1) loginfo << "Looping over channels" << "\n";
    // I need to find out the range of z values which this APA covers, and the number of collection plane wires, in order to correctly assign the channels.
    // --- !!! I am going to explicitly assuming wrapped wires, and that both sides of the TPC are instrumented !!! --- 
    // --- !!! This is valid in all of the geometries that I am aware of 2nd June 2017                          !!! ---
    double ThisAPA_MinZ = DBL_MAX;
    double ThisAPA_MaxZ = -DBL_MAX;
    int    TotColWires  = 0;
    for(auto channel : apa_ptr->getChannels()) {
      if (fGeometryService->View(channel) != 2) continue; // Collection planes wires are view 2.
      ++TotColWires; // Got a collection plane wire.
      // Work out the Z position of this wire.
      double WireSt[3], WireEn[3];
      fGeometryService->WireEndPoints( fGeometryService->ChannelToWire(channel)[0], WireSt, WireEn );
      if (WireSt[2] < ThisAPA_MinZ ) ThisAPA_MinZ = WireSt[2];
      if (WireSt[2] > ThisAPA_MaxZ ) ThisAPA_MaxZ = WireSt[2];
    }
    // --- Work out the number of collection plane wires per board.
    const int NumColWiresPerBoard = TotColWires/fNBoardsPerAPA;
    if (TotColWires%fNBoardsPerAPA != 0) {
      throw cet::exception("HardwareMapperService") << "The number of collection plane wires doesn't divide evenly. There are " << TotColWires << " col wires,"
                                                    << " and you want " << fNBoardsPerAPA << ", leaving a remainder of " << TotColWires%fNBoardsPerAPA << " wires.";
    }
    std::cout << " There are " << TotColWires << " collection plane wires on this APA."
              << " Each board will have " << NumColWiresPerBoard << " collection plane wires, and " << max_channels_in_board - TotColWires/fNBoardsPerAPA << " ind wires."
              << " The wires go from " << ThisAPA_MinZ << " to " << ThisAPA_MaxZ << ".\n"
              << std::endl;

    // --- Set the collection plane wires on our boards.
    int NumColPush = 0, PushToBoard = 0;
    for(auto channel : apa_ptr->getChannels()) {
      if (fGeometryService->View(channel) != 2) continue; // Collection planes wires are view 2.
      // Get the start and end points of the first wire segment for this channel.
      double WireSt[3], WireEn[3];
      fGeometryService->WireEndPoints( fGeometryService->ChannelToWire(channel)[0], WireSt, WireEn );
      BoardsFromAPA[ PushToBoard ]->addChannel(channel);
      ++NumColPush;
      if( WireSt[2] < ZPosOfColWires[ PushToBoard ][0] ) ZPosOfColWires[ PushToBoard ][0] = WireSt[2];
      if( WireEn[2] > ZPosOfColWires[ PushToBoard ][1] ) ZPosOfColWires[ PushToBoard ][1] = WireEn[2];
      ZPosOfColWires[ PushToBoard ][2] = fGeometryService->FindTPCAtPosition( WireSt ).TPC;
      /*
      std::cout << "   Looking at channel " << channel << " on plane " << fGeometryService->View(channel) << " TPC [[" << fGeometryService->FindTPCAtPosition( WireSt ) << " ]]."
                << " Start pos was (" << WireSt[0] << ", " << WireSt[1] << ", " << WireSt[2] << "). "
                << " Endin pos was (" << WireEn[0] << ", " << WireEn[1] << ", " << WireEn[2] << ").\n"
                << "        Pushing it back to board " << PushToBoard << ", now pushed back " << NumColPush << " wires."
                << " Extremes are " << ZPosOfColWires[ PushToBoard ].first << " - " << ZPosOfColWires[ PushToBoard ].second
                << std::endl;
      */
      // --- Check that if I want to move to the next board.
      if ( NumColPush%NumColWiresPerBoard == 0 ) {
        ++PushToBoard;
      }
    }

    for (unsigned int nn=0; nn<fNBoardsPerAPA; ++nn) {
      std::cout << " Looking at board " << BoardsFromAPA[ nn ]->getID() << ", in TPC " << ZPosOfColWires[ nn ][2]
                << " the extremes are " << ZPosOfColWires[ nn ][0] << " - " << ZPosOfColWires[ nn ][1] << std::endl;
    }

    // --- Now set the induction plane wires on our boards.
    int NumIndPush = 0;
    
    for(auto channel : apa_ptr->getChannels()) {
      if (fGeometryService->View(channel) == 2) continue; // Collection planes wires are view 2.
      // --- When looking at induction plane wires whether I look at start or end wire pos depends on APA and TPC number.
      // --- When looking at even APA number - WireEnd   for even TPCs, WireStart for odd TPCs.
      // --- When looking at odd  APA number - WireStart for odd TPCs, WireEnd   for even TPCs.
      // Get the start and end points of the first wire segment for this channel.
      double WireSt[3], WireEn[3];
      fGeometryService->WireEndPoints( fGeometryService->ChannelToWire(channel)[0], WireSt, WireEn );
      /*
      std::cout << "\nLooking at channel " << channel << " on plane " << fGeometryService->View(channel) << " TPC [[" << fGeometryService->FindTPCAtPosition( WireSt ) << " ]]."
                << " Start pos was (" << WireSt[0] << ", " << WireSt[1] << ", " << WireSt[2] << "). "
                << " Endin pos was (" << WireEn[0] << ", " << WireEn[1] << ", " << WireEn[2] << ")."
                << std::endl;
      */
      for (unsigned int nb=0; nb<fNBoardsPerAPA; ++nb) {
        if ( ZPosOfColWires[nb][2] != fGeometryService->FindTPCAtPosition( WireSt ).TPC ) continue;
        if ( (abs(WireSt[1]) > 600 && WireSt[2] > ZPosOfColWires[nb][0] && WireSt[2] < ZPosOfColWires[nb][1] ) ||
             (abs(WireEn[1]) > 600 && WireEn[2] > ZPosOfColWires[nb][0] && WireEn[2] < ZPosOfColWires[nb][1] ) ) {
          BoardsFromAPA[ nb ]->addChannel(channel);
          /*
          std::cout << "   Pushing this channel onto board: " << BoardsFromAPA[ nb ]->getID()
                    << ", Extremeities " << ZPosOfColWires[nb][0] << " - " << ZPosOfColWires[nb][1] << " in TPC " << ZPosOfColWires[nb][2]
                    << ". This board now has " << BoardsFromAPA[ nb ]->getNChannels() << std::endl; 
          */
          break;
        }
      }
      ++NumIndPush;
    }//channel in this apa
    
    // --- Now that I have looped over all of the channels, lets update my map!
    for (unsigned int cb=0; cb<fNBoardsPerAPA; ++cb) {
      unsigned int ThisID = BoardsFromAPA[ cb ]->getID();
      fBoardMap[ ThisID ] = BoardsFromAPA[ cb ];
      std::cout << "Adding board " << BoardsFromAPA[ cb ]->getID() << " to APA " << apa_ptr->getID() 
                << ", it has " << BoardsFromAPA[ cb ]->getNChannels() << " - " << fBoardMap[ ThisID ]->getNChannels()
                << std::endl;
    }
    if(fLogLevel>0) loginfo << "Finished this APA\n" << *apa_ptr << "\n" << "Total Boards in fBoardMap: " << getNBoards() << "\n-----------------------\n\n";
    // --- Start each APA with a new board
    //current_board_id++;
  }//id_apa_pair;
  
  loginfo<< "Finished filling Board Map\n Filled: " << getNBoards() << " Boards";
}

void HardwareMapperService::fillHardwareMaps ( )

private

Definition at line 359 of file HardwareMapperService_service.cc.

                                            {
  const std::string func_name = "fillHardwareMaps";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  fDetectorNameFromGeometry = fGeometryService->DetectorName();

  {
    mf::LogInfo loginfo(fServiceName);
    
    loginfo << "HardwareMapperService\n";
    loginfo << "Filling Hardware Maps using geometry service\n";
    loginfo << "DetectorName: " << fGeometryService->DetectorName() << "\n";
    loginfo << "Ncryostats:   " << fGeometryService->Ncryostats()   << "\n";
    loginfo << "TotalNTPC:    " << fGeometryService->TotalNTPC()    << "\n";
    loginfo << "Nchannels:    " << fGeometryService->Nchannels()    << "\n";
    loginfo << "NOpChannels:  " << fGeometryService->NOpChannels()  << "\n";
  }//using annonymous namespace to force mf::LogInfo destructor call to flush output

  fillTPCMap();
  fillAPAMap();
  fillBoardMap();
  fillASICMap();
  
  mf::LogInfo loginfo(fServiceName);
  loginfo << "Number of TPCs:   " << getNTPCs() << "\n"
          << "Number of APAs:   " << getNAPAs() << "\n"
          << "Number of Boards: " << getNBoards() << "\n"
          << "Number of ASICs:  " << getNASICs() << "\n";

}

void HardwareMapperService::fillTPCMap ( )

private

Definition at line 293 of file HardwareMapperService_service.cc.

                                      {
  const std::string func_name = "fillTPCMap";
  mf::LogInfo loginfo(fServiceName);
  if(fLogLevel>1) loginfo << "In Function: " << func_name << "\n";
  unsigned int Nchannels   = fGeometryService->Nchannels();
  loginfo  << "Filling TPC Map with " << Nchannels << " channels" << "\n";

  for(raw::ChannelID_t channel=0; channel<Nchannels ;channel++){
    std::vector<geo::WireID> const Wires = fGeometryService->ChannelToWire(channel);
    for(auto wire : Wires){
      auto tpc_id = wire.TPC;
      //jpd -- See if we have already created a TPC object for this tpc_id in our map
      auto find_result = fTPCMap.find(tpc_id);
      std::shared_ptr<Hardware::TPC> this_tpc;
      if(find_result != fTPCMap.end()){
        //jpd -- We already have one, add this channel
        this_tpc = (*find_result).second;
      }
      else{
        //jpd -- We don't have one. Create a new one and add this channel
        this_tpc = std::shared_ptr<Hardware::TPC>(new Hardware::TPC(tpc_id));
      }
      this_tpc->addChannel(channel);
      fTPCMap[tpc_id] = this_tpc;
    }//loop over wires
  }//loop over channels
  loginfo  << "Finished filling TPC Map\n"
           << "Filled: " << getNTPCs() << " TPCs";

}

std::vector< raw::ChannelID_t > const & HardwareMapperService::getAPAChannels

(

Hardware::ID

apa_id

)

Definition at line 539 of file HardwareMapperService_service.cc.

                                                                                       {
  const std::string func_name = "getAPAChannels";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  mf::LogInfo loginfo(fServiceName);
  if(fLogLevel>1) loginfo << "Finding channels for APA: " << apa_id << "\n";

  auto find_result = fAPAMap.find(apa_id);
  std::shared_ptr<Hardware::APA> this_apa;
  
  if(find_result == fAPAMap.end()){
    mf::LogError(fServiceName) << "Failed to find this APA: " << apa_id << "\n";
    mf::LogError(fServiceName) << "Returning an empty vector of channels\n";
    static std::vector<raw::ChannelID_t> emptyVector;
    return emptyVector;
  }
  this_apa = (*find_result).second;
  if(fLogLevel>1) loginfo << "Found " << *this_apa << "\n";
  if(fLogLevel>1) loginfo << "\n";
  return this_apa->getChannels();  
}

std::set< raw::ChannelID_t > const & HardwareMapperService::getAPAChannelsSet

(

Hardware::ID

apa_id

)

Definition at line 583 of file HardwareMapperService_service.cc.

                                                                                       {
  const std::string func_name = "getAPAChannelsSet";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  mf::LogInfo loginfo(fServiceName);
  if(fLogLevel>1) loginfo << "Finding channels for APA: " << apa_id << "\n";

  auto find_result = fAPAMap.find(apa_id);
  std::shared_ptr<Hardware::APA> this_apa;
  
  if(find_result == fAPAMap.end()){
    mf::LogError(fServiceName) << "Failed to find this APA: " << apa_id << "\n";
    mf::LogError(fServiceName) << "Returning an empty set of channels\n";
    static std::set<raw::ChannelID_t> emptySet;
    return emptySet;
  }
  this_apa = (*find_result).second;
  if(fLogLevel>1) loginfo << "Found " << *this_apa << "\n";
  if(fLogLevel>1) loginfo << "\n";
  return this_apa->getChannelsSet();  
}

unsigned int HardwareMapperService::getNAPAs ( ) const

inline

Definition at line 54 of file HardwareMapperService.h.

{ return fAPAMap.size();}

unsigned int HardwareMapperService::getNASICs ( ) const

inline

Definition at line 52 of file HardwareMapperService.h.

{ return fASICMap.size();}

unsigned int HardwareMapperService::getNBoards ( ) const

inline

Definition at line 53 of file HardwareMapperService.h.

{ return fBoardMap.size();}

unsigned int HardwareMapperService::getNTPCs ( ) const

inline

Definition at line 55 of file HardwareMapperService.h.

{ return fTPCMap.size();}

std::vector< raw::ChannelID_t > const & HardwareMapperService::getTPCChannels

(

Hardware::ID

tpc_id

)

Definition at line 516 of file HardwareMapperService_service.cc.

                                                                                       {
  const std::string func_name = "getTPCChannels";
  mf::LogInfo loginfo(fServiceName);

  if(fLogLevel>1) loginfo << "In Function: " << func_name << "\n";
  if(fLogLevel>1) loginfo << "Finding channels for TPC: " << tpc_id << "\n";

  auto find_result = fTPCMap.find(tpc_id);
  std::shared_ptr<Hardware::TPC> this_tpc;
  
  if(find_result == fTPCMap.end()){
    mf::LogError(fServiceName) << "Failed to find this TPC: " << tpc_id << "\n";
    mf::LogError(fServiceName) << "Returning an empty vector of channels\n";
    static std::vector<raw::ChannelID_t> emptyVector;
    return emptyVector;
  }
  this_tpc = (*find_result).second;
  if(fLogLevel>1) loginfo << "Found " << *this_tpc << "\n";
  if(fLogLevel>1) loginfo << "\n";
  return this_tpc->getChannels();  
}

std::set< raw::ChannelID_t > const & HardwareMapperService::getTPCChannelsSet

(

Hardware::ID

tpc_id

)

Definition at line 561 of file HardwareMapperService_service.cc.

                                                                                       {
  const std::string func_name = "getTPCChannelsSet";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  mf::LogInfo loginfo(fServiceName);
  if(fLogLevel>1) loginfo << "Finding channels for TPC: " << tpc_id << "\n";

  auto find_result = fTPCMap.find(tpc_id);
  std::shared_ptr<Hardware::TPC> this_tpc;
  
  if(find_result == fTPCMap.end()){
    mf::LogError(fServiceName) << "Failed to find this TPC: " << tpc_id << "\n";
    mf::LogError(fServiceName) << "Returning an empty set of channels\n";
    static std::set<raw::ChannelID_t> emptySet;
    return emptySet;
  }
  this_tpc = (*find_result).second;
  if(fLogLevel>1) loginfo << "Found " << *this_tpc << "\n";
  if(fLogLevel>1) loginfo << "\n";
  return this_tpc->getChannelsSet();  
}

void HardwareMapperService::printAPAMap

(

unsigned int

num_apas_to_print = 20

)

Definition at line 447 of file HardwareMapperService_service.cc.

                                                                     {
  const std::string func_name = "printAPAMap";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  mf::LogInfo loginfo(fServiceName);

  loginfo << "Printing the first: " << num_apas_to_print << " APAs\n";
  unsigned int total_channels = 0;
  unsigned int count = 0;
  for(auto this_pair : fAPAMap ){
    if(count++ >= num_apas_to_print) break;
    std::shared_ptr<Hardware::APA> this_apa = this_pair.second;
    total_channels += this_apa->getNChannels();
    loginfo << *this_apa << "\n";
  }
  loginfo << "\n";
  loginfo << "Total Channels: " << total_channels << "\n";
  loginfo << "\n";
}

void HardwareMapperService::printASICMap

(

unsigned int

num_asics_to_print = 20

)

Definition at line 390 of file HardwareMapperService_service.cc.

                                                                       {
  const std::string func_name = "printASICMap";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  mf::LogInfo loginfo(fServiceName);
  loginfo << "Printing the first: " << num_asics_to_print << " ASICs\n";
  unsigned int total_channels = 0;
  unsigned int count = 0;
  for(auto this_pair : fASICMap ){
    if(count++ >= num_asics_to_print) break;
    std::shared_ptr<Hardware::ASIC> this_asic = this_pair.second;
    total_channels += this_asic->getNChannels();
    loginfo << *this_asic << "\n";
  }
  loginfo << "\n";
  loginfo << "Total Channels: " << total_channels << "\n";
  loginfo << "\n";
}

void HardwareMapperService::printBoardMap

(

unsigned int

num_boards_to_print = 20

)

Definition at line 409 of file HardwareMapperService_service.cc.

                                                                         {
  const std::string func_name = "printBoardMap";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  mf::LogInfo loginfo(fServiceName);
  loginfo << "Printing the first: " << num_boards_to_print << " Boards\n";
  unsigned int total_channels = 0;
  unsigned int count = 0;
  for(auto this_pair : fBoardMap ){
    if(count++ >= num_boards_to_print) break;
    std::shared_ptr<Hardware::Board> this_board = this_pair.second;
    total_channels += this_board->getNChannels();
    loginfo << *this_board << "\n";
  }
  loginfo << "\n";
  loginfo << "Total Channels: " << total_channels << "\n";
  loginfo << "\n";
}

void HardwareMapperService::printGeometryInfo

(

)

Definition at line 491 of file HardwareMapperService_service.cc.

                                             {
  const std::string func_name = "printGeometryInfo";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  {
    mf::LogInfo loginfo(fServiceName);
    loginfo << "Geometry Information with current Geometry Service\n";
    loginfo << "DetectorName: " << fGeometryService->DetectorName() << "\n";
    loginfo << "TotalMass: " << fGeometryService->TotalMass() << "\n";
    unsigned int Ncryostats  = fGeometryService->Ncryostats();
    unsigned int TotalNTPC   = fGeometryService->TotalNTPC();
    unsigned int Nchannels   = fGeometryService->Nchannels();
    unsigned int NOpChannels = fGeometryService->NOpChannels();
    loginfo << "Ncryostats:   " << Ncryostats   << "\n";
    loginfo << "TotalNTPC:    " << TotalNTPC    << "\n";
    loginfo << "Nchannels:    " << Nchannels    << "\n";
    loginfo << "NOpChannels:  " << NOpChannels  << "\n";
    loginfo << "\n";
  }//using annonymous namespace to force mf::LogInfo destructor (which makes flushes the output)

  printHardwareMaps();  

  return;
}

void HardwareMapperService::printHardwareMaps

(

)

Definition at line 467 of file HardwareMapperService_service.cc.

                                             {
  const std::string func_name = "printHardwareMaps";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  mf::LogInfo(fServiceName)  
    << "fDetectorName: " << fDetectorNameFromGeometry << " taken from Geometry Service at time of fillHardwareMaps()" 
    << "\n"
    << "N.B. the geometry service can reload a new geometry on beginRun(), which would be bad"
    << "\n";

  printASICMap(getNASICs());
  printBoardMap(getNBoards());
  printTPCMap(getNTPCs());
  printAPAMap(getNAPAs());


  mf::LogInfo(fServiceName)
    << "Num ASICs: " << getNASICs() << "\n"
    << "Num Boards: " << getNBoards() << "\n"
    << "Num TPCs: " << getNTPCs() << "\n"
    << "Num APAs: " << getNAPAs();

}

void HardwareMapperService::printTPCMap

(

unsigned int

num_tpcs_to_print = 20

)

Definition at line 428 of file HardwareMapperService_service.cc.

                                                                     {
  const std::string func_name = "printTPCMap";
  if(fLogLevel>1) mf::LogInfo(fServiceName) << "In Function: " << func_name;
  mf::LogInfo loginfo(fServiceName);
  loginfo << "Printing the first: " << num_tpcs_to_print << " TPCs\n";
  unsigned int total_channels = 0;
  unsigned int count = 0;
  for(auto this_pair : fTPCMap ){
    if(count++ >= num_tpcs_to_print) break;
    std::shared_ptr<Hardware::TPC> this_tpc = this_pair.second;
    total_channels += this_tpc->getNChannels();
    loginfo << *this_tpc << "\n";
  }
  loginfo << "\n";
  loginfo << "Total Channels: " << total_channels << "\n";
  loginfo << "\n";
}

Member Data Documentation

Hardware::APAMap HardwareMapperService::fAPAMap

private

Definition at line 93 of file HardwareMapperService.h.

Hardware::ASICMap HardwareMapperService::fASICMap

private

Definition at line 90 of file HardwareMapperService.h.

Hardware::BoardMap HardwareMapperService::fBoardMap

private

Definition at line 91 of file HardwareMapperService.h.

std::string HardwareMapperService::fDetectorNameFromFile

private

Definition at line 81 of file HardwareMapperService.h.

std::string HardwareMapperService::fDetectorNameFromGeometry

private

Definition at line 80 of file HardwareMapperService.h.

art::ServiceHandle<geo::Geometry> HardwareMapperService::fGeometryService

private

Definition at line 78 of file HardwareMapperService.h.

unsigned int HardwareMapperService::fLogLevel

private

Definition at line 73 of file HardwareMapperService.h.

unsigned int HardwareMapperService::fNASICsPerBoard

private

Definition at line 74 of file HardwareMapperService.h.

unsigned int HardwareMapperService::fNBoardsPerAPA

private

Definition at line 75 of file HardwareMapperService.h.

std::string HardwareMapperService::fServiceName

private

Definition at line 76 of file HardwareMapperService.h.

Hardware::TPCMap HardwareMapperService::fTPCMap

private

Definition at line 92 of file HardwareMapperService.h.

---

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

• dunecore/dunecore/DAQTriggerSim/Service/HardwareMapperService.h
• dunecore/dunecore/DAQTriggerSim/Service/HardwareMapperService_service.cc