#include "CxxUtils/checker_macros.h"
#include <iostream>
#include <iomanip>
#include <string>
#include <fstream>
#include <sstream>
#include <map>
#include <set>
#include <vector>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include "TSystem.h"
#include "TRT_StrawMap.h"

Functions
void	initializeDeadStrawsList ()

void	simpleAnalysis (const std::string &filename)

void	printAthena (int run)

void	printAthenaBoardsOnly (int run)

void	reportResults (const std::string &filename, int run)

int	main (int argc, char **argv)

Variables
	ATLAS_NO_CHECK_FILE_THREAD_SAFETY

int	deadStraws [2][32][5482]

bool	checkNoisy_HT = false

bool	checkLoEff_HT = false

bool	checkNoisy_LT = false

bool	checkLoEff_LT = true

bool	checkDead_LT = true

bool	onlyMaskBoards = false

Function Documentation

◆ initializeDeadStrawsList()

void initializeDeadStrawsList ( )

Definition at line 121 of file TRTCalib_StrawStatusReport.cxx.

 {
     // compare to input (defined below)
     // assume that input has same format as output:
     // bec sector straw strawlayer layer status
  
     for (int i = 0; i < 2; i++)
         for (int j = 0; j < 32; j++)
             for (int k = 0; k < 5482; k++)
                 deadStraws[i][j][k] = 0;
  
     int tmp[6]; // old length: 3
     int count = 0;
  
     std::string filename = "/afs/cern.ch/user/i/idcalib/w0/TRT_Calibration/tmp/Tier0/StrawStatusCode/TRT_StrawStatus_ExcludedStraws_2023.txt";
  
     FILE *f = fopen(filename.c_str(), "r");
     if (!f)
     {
         std::cout << "TRT_StrawStatusReport::initializePermanentlyDead() ERROR: failed to open the input file " << filename << std::endl;
         std::cout << "TRT_StrawStatusReport::initializePermanentlyDead() ERROR: you need to fix the file name / link, WILL CRASH THE CODE NOW" << std::endl;
         std::abort();
     }
     while (fscanf(f, "%d %d %d %d %d %d\n", tmp, tmp + 1, tmp + 2, tmp + 3, tmp + 4, tmp + 5) == 6)
     {
         //  bec sector strawWithinLayer strawlayer layer status
         strawMap map(tmp[0], tmp[1], tmp[4], tmp[3], tmp[2]);
         if (tmp[5] > 0)
         {
             //coverity[tainted_data]
             deadStraws[(tmp[0] > 0) ? 0 : 1][tmp[1]][map.straw()] = tmp[5];
             count++;
         }
     }
     std::cout << "read " << count << " permanently excluded straws from file " << filename << std::endl;
     fclose(f);
  
     return;
 }

◆ main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 41 of file TRTCalib_StrawStatusReport.cxx.

 {
  
     strawMap straw_global(1, 1, 1);
     initializeDeadStrawsList();
  
     int run = atoi(argv[1]);
     //coverity[tainted_data]
     std::string filename = "straws." + std::to_string(run) + ".txt";
     std::cout << filename << std::endl;
     std::cout << "Created output/ folder.\n";
     gSystem->mkdir("output/",1);
  
     // options for which straws to mask
     for (int i = 2; i < argc; ++i)
     {
         if (std::string(argv[i]) == "checkNoisy_HT")
             checkNoisy_HT = true;
         else if (std::string(argv[i]) == "checkLoEff_HT")
             checkLoEff_HT = true;
         else if (std::string(argv[i]) == "checkNoisy_LT")
             checkNoisy_LT = true;
         else if (std::string(argv[i]) == "checkLoEff_LT")
             checkLoEff_LT = true;
         else if (std::string(argv[i]) == "checkDead_LT")
             checkDead_LT = true;
  
         else if (std::string(argv[i]) == "ignoreNoisy_HT")
             checkNoisy_HT = false;
         else if (std::string(argv[i]) == "ignoreLoEff_HT")
             checkLoEff_HT = false;
         else if (std::string(argv[i]) == "ignoreNoisy_LT")
             checkNoisy_LT = false;
         else if (std::string(argv[i]) == "ignoreLoEff_LT")
             checkLoEff_LT = false;
         else if (std::string(argv[i]) == "ignoreDead_LT")
             checkDead_LT = false;
  
         else if (std::string(argv[i]) == "StatusPermanent")
             onlyMaskBoards = true;
  
         else
         {
             std::cerr << "\n Please use one or several of the following options: \n"
                       << "\n\t - StatusPermanent: to only mask entire dead boards -- for use if updating StatusPermanent "
                       << "\n\t\t - if this option is used, all others will be ignored. \n"
                       << "\n\t - checkNoisy_HT: to mask straws with HT fraction > 0.5 "
                       << "\n\t - checkNoisy_LT: to mask straws with LT fraction > 0.99 "
                       << "\n\t - checkLoEff_HT: to mask straws with HT fraction < 0.0001 "
                       << "\n\t - checkLoEff_LT: to mask straws with LT fraction < 0.7 "
                       << "\n\t - checkDead_LT : to mask straws with LT fraction = 0.0 "
                       << "\n\t Replace \"check\" with \"ignore\" to ignore this category. \n "
                       << std::endl;
             exit(1);
         }
     }
  
     std::cout << "\nOption selection:"
               << "\n - checkNoisy_HT = " << checkNoisy_HT
               << "\n - checkNoisy_LT = " << checkNoisy_LT
               << "\n - checkLoEff_HT = " << checkLoEff_HT
               << "\n - checkLoEff_LT = " << checkLoEff_LT
               << "\n - checkDead_LT  = " << checkDead_LT
               << "\n - StatusPermanent  = " << onlyMaskBoards
               << std::endl;
  
     simpleAnalysis(filename);
     if (onlyMaskBoards)
     {
         printAthenaBoardsOnly(run);
     }
     else
     {
         printAthena(run);
         reportResults(filename, run);
     }
  
     return 1;
 }

◆ printAthena()

void printAthena ( int run )

Definition at line 227 of file TRTCalib_StrawStatusReport.cxx.

 { // print athena format
     // dumps output/athenaFormat_runDependentInactiveStraws_runNUMBER.txt
     // this file is used to update conditions tags
     // lists all problematic straws -- without comparing to reference
     // types of problematic straws to mask can be set on the command line (see options in main)
  
     int count(0);
     int countDeadStraws[] = {0, 0};
     int breakDownOfDeadStraws[100][2];
     for (int i = 0; i < 100; i++)   // different types of dead straw
         for (int j = 0; j < 2; j++) // barrel / end-caps
             breakDownOfDeadStraws[i][j] = 0;
  
     std::string filename = "output/athenaFormat_runDependentInactiveStraws_run" + std::to_string(run) + ".txt";
     std::cout << filename << endl;
     FILE *fout = fopen(filename.c_str(), "w");
     assert(fout);
  
     for (int i = 0; i < 2; i++)
     {
         for (int j = 0; j < 32; j++)
         {
             for (int k = 0; k < 5482; k++)
             {
                 if (!deadStraws[i][j][k])
                     continue; // ignore good straws for now
  
                 int side = (i != 0 ? -1 : 1);
                 if (k >= 1642)
                     side *= 2;
  
                 strawMap map(side, j, k);
  
                 if (deadStraws[i][j][k] > 0)
                 {
                     // for compatibility with upload (via txt2db_template.py)
                     // ONLY SET STRAWS DEAD THAT SHOULD BE CHECKED
                     // THIS SETS ALL TYPES OF DEAD THAT ARE CHECKED TO 1
                     if (deadStraws[i][j][k] == 1)
                         fprintf(fout, "%2d %2d %2d %2d %2d %2d\n", side, j, map.strawWithinLayer(), map.strawLayer(), map.layer(), 1);
                     if ((deadStraws[i][j][k] == 11 && checkNoisy_LT) 
                         || (deadStraws[i][j][k] == 12 && checkDead_LT) 
                         || (deadStraws[i][j][k] == 42 && checkLoEff_LT) 
                         || (deadStraws[i][j][k] == 51 && checkNoisy_HT) 
                         || (deadStraws[i][j][k] == 52 && checkLoEff_HT)
                         )
                         fprintf(fout, "%2d %2d %2d %2d %2d %2d\n", side, j, map.strawWithinLayer(), map.strawLayer(), map.layer(), 1);
  
                     // do not dump to command-line straws that are already on the dead straw list (which will all be marked 1 due to previous line)
                     // but dump them to command line even if m_checkBLAH is false
                     if (deadStraws[i][j][k] > 1)
                     {
                         breakDownOfDeadStraws[deadStraws[i][j][k]][(k < 1642) ? 0 : 1]++;
                         count++;
                         countDeadStraws[(fabs(side) == 1) ? 0 : 1]++;
                     }
                 }
             }
         }
     }
  
     printf("found %d newly dead straws compared to %s \n", count, filename.c_str());
     printf("N dead straws in TRT barrel: %4d or %4.1lf%%\n", countDeadStraws[0], (100. * countDeadStraws[0]) / (64. * 1642));
     printf("N dead straws in TRT end-caps: %4d or %4.1lf%%\n", countDeadStraws[1], (100. * countDeadStraws[1]) / (64. * 20 * 192));
     printf("overall: %4.2lf%%\n", 100. * count / 350848.);
  
     fclose(fout);
  
     std::cout << "criteria barrel end-cap" << std::endl;
     for (int i = 2; i < 100; i++)
         if (breakDownOfDeadStraws[i][0] + breakDownOfDeadStraws[i][1])
             printf("%2d %4d %4d\n", i, breakDownOfDeadStraws[i][0], breakDownOfDeadStraws[i][1]);
  
     return;
 }

◆ printAthenaBoardsOnly()

void printAthenaBoardsOnly ( int run )

Definition at line 304 of file TRTCalib_StrawStatusReport.cxx.

 { // print athena format
     // dumps output/athenaFormat_runDependentInactiveStraws_runNUMBER.txt
     // ONLY FOR ENTIRE DEAD BOARDS
     // this file is used to update conditions tags
     // lists all problematic straws -- without comparing to reference
     // types of problematic straws to mask can be set on the command line (see options in main)
  
     std::string filename = "output/athenaFormat_DeadBoards_run" + std::to_string(run) + ".txt";
     std::cout << filename << endl;
     FILE *fout = fopen(filename.c_str(), "w");
     assert(fout);
  
     for (int i = 0; i < 2; i++)
     {
         for (int j = 0; j < 32; j++)
         {
             std::vector<int> allStrawsOnBoard[29]; // (9  boards in barrel, 20 in endcap)
             std::vector<int> deadStrawsOnBoard[29];
             std::vector<int> newDeadStrawsOnBoard[29];
  
             for (int k = 0; k < 5482; k++)
             {
                 int side = (i != 0 ? -1 : 1);
  
                 if (k >= 1642)
                     side *= 2;
                 strawMap map(side, j, k);
                 int board = map.TTCgroup();
  
                 // make a vector of all straws on a given board
                 // and make a vector of dead straws on a given board
                 // if the vector lengths match then the board is dead
                 // and we can use the straw list in the vector to mask them
                 if (board <0) continue;
                 allStrawsOnBoard[board].push_back(k);
                 if (deadStraws[i][j][k] > 0)
                     deadStrawsOnBoard[board].push_back(k);
                 if (deadStraws[i][j][k] > 1)
                     newDeadStrawsOnBoard[board].push_back(k);
             }
  
             for (int board = 0; board < 29; ++board)
             {
                 if (allStrawsOnBoard[board].size() == deadStrawsOnBoard[board].size())
                 {
                     // then the board is dead and we should mask all straws
  
                     for (unsigned int it = 0; it < deadStrawsOnBoard[board].size(); it++)
                     {
                         int k = deadStrawsOnBoard[board].at(it);
                         int side = (i != 0 ? -1 : 1);
                         if (k >= 1642)
                             side *= 2;
                         strawMap map(side, j, k);
                         fprintf(fout, "%2d %2d %2d %2d %2d %2d\n", side, j, map.strawWithinLayer(), map.strawLayer(), map.layer(), 1);
                     }
                 }
  
                 if (allStrawsOnBoard[board].size() == newDeadStrawsOnBoard[board].size())
                 {
                     // then we found a new dead board
                     int side = (i != 0 ? -1 : 1);
                     std::cout << "found a new dead board!!! " << std::endl;
                     std::cout << "See TRT_StrawMap.h for board ID info " << std::endl;
                     std::cout << "side: " << side << ", phi: " << j << ", board ID: " << board << std::endl
                               << std::endl;
                 }
             }
         }
     }
     fclose(fout);
     return;
 }

◆ reportResults()

void reportResults	(	const std::string &	filename,
		int	run
	)

Definition at line 379 of file TRTCalib_StrawStatusReport.cxx.

 {
     // creates TRT_StrawStatusReport.txt
     // this file used to make histograms via TRT_StrawStatusReport.C
  
     FILE *f = fopen(filename.c_str(), "r");
     assert(f);
     int count(0), nevents(0), tmp[9];
     FILE *fout = fopen("TRT_StrawStatusReport.txt", "w");
     if (!fout) {
       printf ("Cannot open output file");
       exit(1);
     }
     fprintf(fout, "%d %d %d %d %d %lf %lf %lf %2d\n", 0, 0, 0, 0, run, 0., 0., 0., 0);
     //what do these numbers mean, what are valid ranges for them?
     while (fscanf(f, "%d %d %d %d %d %d %d %d %d\n", tmp, tmp + 1, tmp + 2, tmp + 3, tmp + 4, tmp + 5, tmp + 6, tmp + 7, tmp + 8) == 9)
     {
  
         if (tmp[0] == 0 && tmp[1] == 0 && tmp[2] == 0 && tmp[3] == 0 && tmp[4] == 0 && tmp[5] == 0 && tmp[6] == 0 && tmp[7] == 0)
         {
             nevents = tmp[8];
             continue;
         }
         if (nevents == 0) continue;
         count++;
  
         double occupancy = 1. * tmp[3] / nevents;
         double HToccupancy = 1. * tmp[5] / nevents;
         double efficiency = (tmp[4] + tmp[7] > 0) ? (1. * tmp[4] / (tmp[4] + tmp[7])) : 0.;
  
         int side = int(tmp[0]);
         int j = int(tmp[1]);
         int k = int(tmp[2]);
         strawMap map(side, j, k);
         //coverity[tainted_data]
         fprintf(fout, "%d %d %d %d %d %lf %lf %lf %2d\n", tmp[0], tmp[1], tmp[2], deadStraws[(tmp[0] > 0) ? 0 : 1][tmp[1]][tmp[2]], tmp[4], occupancy, HToccupancy, efficiency, map.layer());
     }
  
     std::cout << "reportResults: read " << count << " lines from file " << filename << ", wrote to TRT_StrawStatusReport.txt" << std::endl;
     fclose(f);
     fclose(fout);
  
     return;
 }

◆ simpleAnalysis()

void simpleAnalysis ( const std::string & filename )

Definition at line 161 of file TRTCalib_StrawStatusReport.cxx.

 {
     // input format of straws.RUNNUMBER.txt:
     // bec, phi, strawID, # hits, # track hits, # HT hits, # HT track hits, # holes, # holes with hit (hit not assigned to track)
     std::cout << "simpleAnalysis: reading file " << filename << std::endl;
     FILE *f = fopen(filename.c_str(), "r");
     assert(f);
     int countlines(0), nevents(0), tmp[9];
  
     while (fscanf(f, "%d %d %d %d %d %d %d %d %d\n", tmp, tmp + 1, tmp + 2, tmp + 3, tmp + 4, tmp + 5, tmp + 6, tmp + 7, tmp + 8) == 9)
     {
  
         if (tmp[0] == 0 && tmp[1] == 0 && tmp[2] == 0 && tmp[3] == 0 && tmp[4] == 0 && tmp[5] == 0 && tmp[6] == 0 && tmp[7] == 0)
         {
             nevents = tmp[8];
             continue;
         }
         if (nevents == 0) continue;
         countlines++;
  
         double occupancy = 1. * tmp[3] / nevents;
         double HToccupancy = 1. * tmp[5] / nevents;
         double efficiency = (tmp[4] + tmp[7] > 0) ? (1. * tmp[4] / (tmp[4] + tmp[7])) : 0.;
  
         int skip = 0;
  
         if (onlyMaskBoards && tmp[3] == 0)
             skip = 12;
         else
         {
             // ignore all other possible types of bad straw if we're masking dead boards
             if (HToccupancy > 0.5   ) skip = 51; // high HT fraction straws
             if (HToccupancy < 0.0001) skip = 52; // low HT fraction straws
             if (efficiency < 0.7    ) skip = 42; // low efficiency LT straws
             if (occupancy > 0.99    ) skip = 11; // 100% occupancy straws
  
             if (tmp[3] == 0         ) skip = 12; // 0 hits
         }
         //coverity[tainted_data]
         if (deadStraws[(tmp[0] > 0) ? 0 : 1][tmp[1]][tmp[2]] == 1)
         {
             if (!onlyMaskBoards)
             {
                 // this assumes the same qualities were checked in the reference.
                 // if that is not true, you'll get a lot of print out.
                 // that's why we don't do this check for the board-level masking.
                 if ((tmp[3] == 0 && checkDead_LT) 
                     || (occupancy > 0.99 && checkNoisy_LT) 
                     || (efficiency < 0.7 && checkLoEff_LT) 
                     || (HToccupancy < 0.0001 && checkLoEff_HT) 
                     || (HToccupancy > 0.5 && checkNoisy_HT)
                     )
                     continue;
                 std::cout << "read ONE straw permanently masked is ALIVE!!! " << tmp[0] << ", " << tmp[1] << ", " << tmp[2] << ", hits: " << tmp[3] << ", occ: " << occupancy << ", eff: " << efficiency << std::endl;
             }
         }
  
         if (skip && !deadStraws[(tmp[0] > 0) ? 0 : 1][tmp[1]][tmp[2]]) deadStraws[(tmp[0] > 0) ? 0 : 1][tmp[1]][tmp[2]] = skip;
     }
  
     std::cout << "read " << countlines << " lines from file " << filename << ", N events: " << nevents << std::endl;
     fclose(f);
  
     return;
 }