diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
index a21af64c586eb59b1dcc2aa236501c524e7493c2..304409d599c0db06838b8062eea026cbeefbf2c1 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
@@ -124,27 +124,27 @@ class TileCisDefaultCalibTool: public AthAlgTool
bool m_doSampleChecking;
// Results
- float m_calib[5][64][48][2];
- int m_qflag[5][64][48][2];
- int m_nDAC[5][64][48][2]; // This is now deprecated since you can get this form the TGraph
- int m_nDigitalErrors[5][64][48][2];
- float m_chi2[5][64][48][2];
+ float (*m_calib)[64][48][2];
+ int (*m_qflag)[64][48][2];
+ int (*m_nDAC)[64][48][2]; // This is now deprecated since you can get this form the TGraph
+ int (*m_nDigitalErrors)[64][48][2];
+ float (*m_chi2)[64][48][2];
// These will not be saved to the ntuple
// They are for the sample check that gets written to qflag
// Mike Miller - 4 June 2009
- int m_edgeSample[5][64][48][2];
- int m_nextToEdgeSample[5][64][48][2];
+ int (*m_edgeSample)[64][48][2];
+ int (*m_nextToEdgeSample)[64][48][2];
// these arrays are used to contain information about stuck bits in adc's
// this array pertains to the "stuck bit" quality flag; it is not written to
// the ntuple
- int m_SampleBit[5][64][48][2][10];
+ int (*m_sampleBit)[64][48][2][10];
// This array contains information about each bit in the adc
// it IS written into the ntuple
- unsigned short m_BitStatus[5][64][48][2][4];
+ unsigned short (*m_bitStatus)[64][48][2][4];
// used to count the number of injection samples analyzed for odd bit behavior
- int m_NumSamp[5][64][48][2];
+ int (*m_numSamp)[64][48][2];
// TList *scanList; // This is now deprecated and replaced by the map for speed -CT March 09
TMap* m_scanMap;
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
index 5c01388b45ea5a174884bb6843b14adec363f70d..db032623518e8cb7489f45038e8946b12da3ce8b 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
@@ -117,14 +117,14 @@ class TileDigiNoiseCalibAlg: public AthAlgorithm {
std::string m_optRawChannelContainer;*/
std::string m_dspRawChannelContainer;
- double m_SumPed2[5][64][48][2];
- double m_SumRms2[5][64][48][2];
- double m_MeanAmp[5][64][48][2];
- double m_MeanAmp_ij[5][64][48][48][2];
+ double (*m_sumPed2)[64][48][2];
+ double (*m_sumRms2)[64][48][2];
+ double (*m_meanAmp)[64][48][2];
+ double (*m_meanAmp_ij)[64][48][48][2];
// event number
int m_evtNr;
- int m_evt[5][64][48][2];
+ int (*m_evt)[64][48][2];
// Trigger items
int m_time;
@@ -136,15 +136,15 @@ class TileDigiNoiseCalibAlg: public AthAlgorithm {
int m_min;
int m_run;
int m_trigType;
- uint8_t m_ros[5][64][48][2];
- uint8_t m_drawer[5][64][48][2];
- uint8_t m_channel[5][64][48][2];
- bool m_gain[5][64][48][2];
- float m_ped[5][64][48][2];
- float m_lfn[5][64][48][2];
- float m_hfn[5][64][48][2];
- float m_noise_cov[5][64][2];
- float m_auto_corr[5][64][48][2][36];
+ uint8_t (*m_ros)[64][48][2];
+ uint8_t (*m_drawer)[64][48][2];
+ uint8_t (*m_channel)[64][48][2];
+ bool (*m_gain)[64][48][2];
+ float (*m_ped)[64][48][2];
+ float (*m_lfn)[64][48][2];
+ float (*m_hfn)[64][48][2];
+ float (*m_noise_cov)[64][2];
+ float (*m_auto_corr)[64][48][2][36];
};
#endif // TILENOISECALIBALG_H
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileRawChNoiseCalibAlg.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileRawChNoiseCalibAlg.h
index cdf5177be407710c5f8dea6873c82235111d39d1..2d47cf41d3df2d84521da82048441da5b48158bd 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileRawChNoiseCalibAlg.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileRawChNoiseCalibAlg.h
@@ -71,7 +71,6 @@ class TileRawChNoiseCalibAlg: public AthAlgorithm {
const SG::ReadHandleKey<TileRawChannelContainer>& rawChannelContainerKey,
RCtype rctype); // raw chans variables is done here
void StoreRunInfo(const TileDQstatus* dqStatus); // called only at the first event. General variables
- void removeRC(RCtype rctype); // if a RawChannel container doesn't exist, it is removed from the list
void fillCell(TileRawChannelUnit::UNIT RChUnit, const TileRawChannel * rch);
void fillCellHist(); //fill HGHG and LGLG histograms
@@ -156,16 +155,16 @@ class TileRawChNoiseCalibAlg: public AthAlgorithm {
std::string m_OF1RawChannelContainer;
std::string m_MFRawChannelContainer;
- TH1F* m_histAmp[RCnum][5][64][48][2];
- TH1F* m_histCellAmp[2][64][4][17][6];
+ TH1F* (*m_histAmp)[5][64][48][2];
+ TH1F* (*m_histCellAmp)[64][4][17][6];
// event number
int m_evtNr;
- int m_evt[5][64][48][2];
- uint8_t m_ros[5][64][48][2];
- uint8_t m_drawer[5][64][48][2];
- uint8_t m_channel[5][64][48][2];
- bool m_gain[5][64][48][2];
+ int (*m_evt)[64][48][2];
+ uint8_t (*m_ros)[64][48][2];
+ uint8_t (*m_drawer)[64][48][2];
+ uint8_t (*m_channel)[64][48][2];
+ bool (*m_gain)[64][48][2];
// Trigger items
int m_time;
int m_year;
@@ -179,27 +178,27 @@ class TileRawChNoiseCalibAlg: public AthAlgorithm {
//int m_nsamples;
// RawCh items
- float m_rc_mean[RCnum][5][64][48][2];
- float m_rc_sigma[RCnum][5][64][48][2];
- float m_rc_av[RCnum][5][64][48][2];
- float m_rc_rms[RCnum][5][64][48][2];
- float m_rc_skewness[RCnum][5][64][48][2];
- float m_rc_kurtosis[RCnum][5][64][48][2];
- float m_rc_mean_err[RCnum][5][64][48][2];
- float m_rc_sigma_err[RCnum][5][64][48][2];
- float m_rc_chi2[RCnum][5][64][48][2];
- float m_rc_ndf[RCnum][5][64][48][2];
- float m_rc_probC2[RCnum][5][64][48][2];
-
- float m_rc_ggpar[RCnum][5][64][48][2][8]; // sigma gauss1, rel normalization of the gaussians, sigma gauss2, chi2/ndf, error in sigma1, sigma2 and normalization, correlation between sigma1 and sigma2
- float m_rc_gsigma1[RCnum][5][64][48][2];
- float m_rc_gsigma2[RCnum][5][64][48][2];
- float m_rc_gnorm[RCnum][5][64][48][2];
- float m_rc_gchi2[RCnum][5][64][48][2];
- float m_rc_gerrsigma1[RCnum][5][64][48][2];
- float m_rc_gerrsigma2[RCnum][5][64][48][2];
- float m_rc_gerrnorm[RCnum][5][64][48][2];
- float m_rc_gcorrsigma1sigma2[RCnum][5][64][48][2];
+ float (*m_rc_mean)[5][64][48][2];
+ float (*m_rc_sigma)[5][64][48][2];
+ float (*m_rc_av)[5][64][48][2];
+ float (*m_rc_rms)[5][64][48][2];
+ float (*m_rc_skewness)[5][64][48][2];
+ float (*m_rc_kurtosis)[5][64][48][2];
+ float (*m_rc_mean_err)[5][64][48][2];
+ float (*m_rc_sigma_err)[5][64][48][2];
+ float (*m_rc_chi2)[5][64][48][2];
+ float (*m_rc_ndf)[5][64][48][2];
+ float (*m_rc_probC2)[5][64][48][2];
+
+ float (*m_rc_ggpar)[5][64][48][2][8]; // sigma gauss1, rel normalization of the gaussians, sigma gauss2, chi2/ndf, error in sigma1, sigma2 and normalization, correlation between sigma1 and sigma2
+ float (*m_rc_gsigma1)[5][64][48][2];
+ float (*m_rc_gsigma2)[5][64][48][2];
+ float (*m_rc_gnorm)[5][64][48][2];
+ float (*m_rc_gchi2)[5][64][48][2];
+ float (*m_rc_gerrsigma1)[5][64][48][2];
+ float (*m_rc_gerrsigma2)[5][64][48][2];
+ float (*m_rc_gerrnorm)[5][64][48][2];
+ float (*m_rc_gcorrsigma1sigma2)[5][64][48][2];
//Cell items
//structure is side: A=0 C=1,
@@ -207,27 +206,27 @@ class TileRawChNoiseCalibAlg: public AthAlgorithm {
// sample: A=0, BC=1, D=2, E=3
// tower: 0-16,
// gain combination: LGLG, LG-, -LG, HGHG, HG-, -HG
- bool m_side[2][64][4][17][6];
- uint8_t m_phi[2][64][4][17][6];
- uint8_t m_sample[2][64][4][17][6];
- uint8_t m_tower[2][64][4][17][6];
- uint8_t m_gg[2][64][4][17][6];
-
- float m_ecell_av[2][64][4][17][6];
- float m_ecell_rms[2][64][4][17][6];
- uint32_t m_ecell_hash[2][64][4][17];
-
- int m_cell_nch[2][64][4][17][2]; // number of good channels in given cell in given event - 0 or 1 or 2
- float m_ecell_ene[2][64][4][17][2];
- float m_ggpar[2][64][4][17][6][8]; // sigma gauss1, rel normalization of the gaussians, sigma gauss2, chi2/ndf, error in sigma1, sigma2 and normalization, correlation between sigma1 and sigma2
- float m_gsigma1[2][64][4][17][6];
- float m_gsigma2[2][64][4][17][6];
- float m_gnorm[2][64][4][17][6];
- float m_gchi2[2][64][4][17][6];
- float m_gerrsigma1[2][64][4][17][6];
- float m_gerrsigma2[2][64][4][17][6];
- float m_gerrnorm[2][64][4][17][6];
- float m_gcorrsigma1sigma2[2][64][4][17][6];
+ bool (*m_side)[64][4][17][6];
+ uint8_t (*m_phi)[64][4][17][6];
+ uint8_t (*m_sample)[64][4][17][6];
+ uint8_t (*m_tower)[64][4][17][6];
+ uint8_t (*m_gg)[64][4][17][6];
+
+ float (*m_ecell_av)[64][4][17][6];
+ float (*m_ecell_rms)[64][4][17][6];
+ uint32_t (*m_ecell_hash)[64][4][17];
+
+ int (*m_cell_nch)[64][4][17][2]; // number of good channels in given cell in given event - 0 or 1 or 2
+ float (*m_ecell_ene)[64][4][17][2];
+ float (*m_ggpar)[64][4][17][6][8]; // sigma gauss1, rel normalization of the gaussians, sigma gauss2, chi2/ndf, error in sigma1, sigma2 and normalization, correlation between sigma1 and sigma2
+ float (*m_gsigma1)[64][4][17][6];
+ float (*m_gsigma2)[64][4][17][6];
+ float (*m_gnorm)[64][4][17][6];
+ float (*m_gchi2)[64][4][17][6];
+ float (*m_gerrsigma1)[64][4][17][6];
+ float (*m_gerrsigma2)[64][4][17][6];
+ float (*m_gerrnorm)[64][4][17][6];
+ float (*m_gcorrsigma1sigma2)[64][4][17][6];
enum CELL_CHANNEL {OUTER_MBTS_CHANNEL = 4, SPECIAL_C10_CHANNEL = 5, E1_CHANNEL = 12};
};
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTOFTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTOFTool.h
index 2e4a18aa144c74d4431e8b5f221dad355f8c3fcf..f14808f0a57ef1e42471847ce6ead681018966c1 100755
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTOFTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTOFTool.h
@@ -43,7 +43,7 @@ class TileTOFTool : public AthAlgTool, virtual public ITileCalibTool
float timeCor(int mod_ref1, int mod_ref2, int part_ref1, int part_ref2);
- float m_TimeCor[4][64];
+ float (*m_timeCor)[64];
float m_LBA_LBC[4];
float m_LBA_EBA[4];
@@ -56,8 +56,8 @@ class TileTOFTool : public AthAlgTool, virtual public ITileCalibTool
float m_LA_LC;
float m_LA_EC;
- float m_tcor[4][32][32];
- int m_Npair[4][32][32];
+ float (*m_tcor)[32][32];
+ int (*m_nPair)[32][32];
};
#endif
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
index cb828261d57d619bda1d7a94a1b5347c877ce096..0002708fdbc42d6e51107f30292fab885106af64 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
@@ -66,27 +66,27 @@ class TileTriggerDefaultCalibTool : public AthAlgTool, virtual public ITileCalib
"TriggerTowerContainer", "xAODTriggerTowers", "Trigger Tower container"};
// Results Tile
- float m_meanTile[5][64][48];
- float m_rmsTile[5][64][48];
- float m_meanTileDAC[5][64][48];
- float m_rmsTileDAC[5][64][48];
- int m_ietaTile[5][64][48];
- int m_iphiTile[5][64][48];
- int m_ipmtTile[5][64][48];
- int m_nEvtTile[5][64][48];
+ float (*m_meanTile)[64][48];
+ float (*m_rmsTile)[64][48];
+ float (*m_meanTileDAC)[64][48];
+ float (*m_rmsTileDAC)[64][48];
+ int (*m_ietaTile)[64][48];
+ int (*m_iphiTile)[64][48];
+ int (*m_ipmtTile)[64][48];
+ int (*m_nEvtTile)[64][48];
// Results L1Calo
- float m_meanL1Calo[5][64][48];
- float m_rmsL1Calo[5][64][48];
- float m_meanL1CaloDAC[5][64][48];
- float m_rmsL1CaloDAC[5][64][48];
- int m_ietaL1Calo[5][64][48];
- int m_iphiL1Calo[5][64][48];
- int m_ipmtL1Calo[5][64][48];
- int m_nEvtL1Calo[5][64][48];
-
- float m_meanTileL1Calo[5][64][48];
- float m_rmsTileL1Calo[5][64][48];
+ float (*m_meanL1Calo)[64][48];
+ float (*m_rmsL1Calo)[64][48];
+ float (*m_meanL1CaloDAC)[64][48];
+ float (*m_rmsL1CaloDAC)[64][48];
+ int (*m_ietaL1Calo)[64][48];
+ int (*m_iphiL1Calo)[64][48];
+ int (*m_ipmtL1Calo)[64][48];
+ int (*m_nEvtL1Calo)[64][48];
+
+ float (*m_meanTileL1Calo)[64][48];
+ float (*m_rmsTileL1Calo)[64][48];
float m_DACvalue;
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
index a136b6fb1612b282eec4f4c12d74c12a1116bfae..c263cc95b42ee96f5987b84c2ee9ba7acef6f5b1 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
@@ -66,29 +66,41 @@ TileCisDefaultCalibTool::TileCisDefaultCalibTool(const std::string& type, const
declareProperty("doSampleChecking", m_doSampleChecking = true); // do sample checking by default
declareProperty("StuckBitsProbsTool", m_stuckBitsProbs);
declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
+
+ // Initialize arrays for results
+ m_calib = new float[5][64][48][2]();
+ m_qflag = new int[5][64][48][2]();
+ m_nDAC = new int[5][64][48][2]();
+ m_nDigitalErrors = new int[5][64][48][2]();
+ m_chi2 = new float[5][64][48][2]();
+
+ // Initialize sample check arrays
+ m_edgeSample = new int[5][64][48][2]();
+ m_nextToEdgeSample = new int[5][64][48][2]();
+
+ m_sampleBit = new int[5][64][48][2][10]();
+ m_bitStatus = new unsigned short[5][64][48][2][4]();
+ m_numSamp = new int[5][64][48][2]();
}
TileCisDefaultCalibTool::~TileCisDefaultCalibTool() {
+
+ delete[] m_calib;
+ delete[] m_qflag;
+ delete[] m_nDAC;
+ delete[] m_nDigitalErrors;
+ delete[] m_chi2;
+ delete[] m_edgeSample;
+ delete[] m_nextToEdgeSample;
+ delete[] m_sampleBit;
+ delete[] m_bitStatus;
+ delete[] m_numSamp;
+
}
StatusCode TileCisDefaultCalibTool::initialize() {
ATH_MSG_INFO( "initialize()" );
- // Initialize arrays for results
- memset(m_calib, 0, sizeof(m_calib));
- memset(m_qflag, 0, sizeof(m_qflag));
- memset(m_nDAC, 0, sizeof(m_nDAC));
- memset(m_nDigitalErrors, 0, sizeof(m_nDigitalErrors));
- memset(m_chi2, 0, sizeof(m_chi2));
-
- // Initialize sample check arrays
- memset(m_edgeSample, 0, sizeof(m_edgeSample));
- memset(m_nextToEdgeSample, 0, sizeof(m_nextToEdgeSample));
-
- memset(m_SampleBit, 0, sizeof(m_SampleBit));
- memset(m_BitStatus, 0, sizeof(m_BitStatus));
- memset(m_NumSamp, 0, sizeof(m_NumSamp));
-
// get TileHWID helper
CHECK( detStore()->retrieve(m_tileHWID) );
@@ -99,7 +111,7 @@ StatusCode TileCisDefaultCalibTool::initialize() {
CHECK( m_dqStatusKey.initialize() );
ATH_CHECK( m_rawChannelContainerKey.initialize() );
- ATH_CHECK( m_digitsContainerKey.initialize() );
+ ATH_CHECK( m_digitsContainerKey.initialize(m_doSampleChecking) );
return StatusCode::SUCCESS;
}
@@ -271,7 +283,7 @@ StatusCode TileCisDefaultCalibTool::execute() {
for(unsigned int sampNum = 0; sampNum < theDigits.size(); sampNum++) {
// Count the total number of samples taken by an ADC
- m_NumSamp[ros][drawer][chan][gain] += 1;
+ m_numSamp[ros][drawer][chan][gain] += 1;
int k = 0;
int quotient = theDigits[sampNum];
@@ -279,7 +291,7 @@ StatusCode TileCisDefaultCalibTool::execute() {
while(quotient!=0) {
if((quotient % 2) == 1) {
// If the bit is one, store info in the array
- m_SampleBit[ros][drawer][chan][gain][k] += 1;
+ m_sampleBit[ros][drawer][chan][gain][k] += 1;
}
quotient = quotient / 2;
@@ -557,19 +569,19 @@ StatusCode TileCisDefaultCalibTool::finalizeCalculations() {
int NoStuckBit = 1;
for(int i = 0; i < 10; i++) {
// If a bit is stuck at zero...
- if(m_SampleBit[ros][drawer][chan][gain][i] == 0 && (m_NumSamp[ros][drawer][chan][gain] != 0)) {
- // write information to m_BitStatus array of shorts
+ if(m_sampleBit[ros][drawer][chan][gain][i] == 0 && (m_numSamp[ros][drawer][chan][gain] != 0)) {
+ // write information to m_bitStatus array of shorts
// each bit in short corresponds to a bit in an adc
// with 6 short bits left over
- m_BitStatus[ros][drawer][chan][gain][0] += pow(2, i);
+ m_bitStatus[ros][drawer][chan][gain][0] += pow(2, i);
NoStuckBit = 0;
ATH_MSG_DEBUG( "\n\nBIT STUCK AT ZERO: "
<< ros << " " << drawer << " " << chan << " " << gain << " " << i << "\n");
}
// Same for a bit stuck at one
- else if (m_SampleBit[ros][drawer][chan][gain][i] == m_NumSamp[ros][drawer][chan][gain] && (m_NumSamp[ros][drawer][chan][gain] != 0)) {
- m_BitStatus[ros][drawer][chan][gain][1] += pow(2, i);
+ else if (m_sampleBit[ros][drawer][chan][gain][i] == m_numSamp[ros][drawer][chan][gain] && (m_numSamp[ros][drawer][chan][gain] != 0)) {
+ m_bitStatus[ros][drawer][chan][gain][1] += pow(2, i);
NoStuckBit = 0;
ATH_MSG_DEBUG( "\n\nBIT STUCK AT ONE: "
<< ros << " " << drawer << " " << chan << " " << gain << " " << i << "\n");
@@ -603,7 +615,7 @@ StatusCode TileCisDefaultCalibTool::writeNtuple(int runNumber, int runType, TFil
t->Branch("nDAC", *m_nDAC, "nDAC[5][64][48][2]/I");
t->Branch("nDigitalErrors", *m_nDigitalErrors, "nDigitalErrors[5][64][48][2]/I");
t->Branch("chi2", *m_chi2, "chi2[5][64][48][2]/F");
- t->Branch("BitStatus", *m_BitStatus, "BitStatus[5][64][48][2][4]/s");
+ t->Branch("BitStatus", *m_bitStatus, "BitStatus[5][64][48][2][4]/s");
if (!m_stuckBitsProbs.empty()) {
if (m_stuckBitsProbs.retrieve().isFailure()) {
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
index 0253c1d8f645e7f54e21ead756eef73a7330d0d7..79fbe223b9f97c5c8e706eb84d337c32bd221574 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
@@ -84,30 +84,45 @@ TileDigiNoiseCalibAlg::TileDigiNoiseCalibAlg(const std::string& name, ISvcLocato
m_run = 0;
m_evtNr = -1;
+
+ m_sumPed2 = new double[5][64][48][2]();
+ m_sumRms2 = new double[5][64][48][2]();
+ m_meanAmp = new double[5][64][48][2]();
+ m_meanAmp_ij = new double[5][64][48][48][2]();
+ m_evt = new int[5][64][48][2]();
+ m_ros = new uint8_t[5][64][48][2]();
+ m_drawer = new uint8_t[5][64][48][2]();
+ m_channel = new uint8_t[5][64][48][2]();
+ m_gain = new bool[5][64][48][2]();
+ m_ped = new float[5][64][48][2]();
+ m_lfn = new float[5][64][48][2]();
+ m_hfn = new float[5][64][48][2]();
+ m_noise_cov = new float[5][64][2]();
+ m_auto_corr = new float[5][64][48][2][36]();
}
TileDigiNoiseCalibAlg::~TileDigiNoiseCalibAlg() {
+
+ delete[] m_sumPed2;
+ delete[] m_sumRms2;
+ delete[] m_meanAmp;
+ delete[] m_meanAmp_ij;
+ delete[] m_evt;
+ delete[] m_ros;
+ delete[] m_drawer;
+ delete[] m_channel;
+ delete[] m_gain;
+ delete[] m_ped;
+ delete[] m_lfn;
+ delete[] m_hfn;
+ delete[] m_noise_cov;
+ delete[] m_auto_corr;
}
/// Only array initialization is done here
/// All the helpers initialization is done at the first event
StatusCode TileDigiNoiseCalibAlg::initialize() {
- memset(m_SumPed2, 0, sizeof(m_SumPed2));
- memset(m_SumRms2, 0, sizeof(m_SumRms2));
- memset(m_MeanAmp, 0, sizeof(m_MeanAmp));
- memset(m_MeanAmp_ij, 0, sizeof(m_MeanAmp_ij));
- memset(m_evt, 0, sizeof(m_evt));
- memset(m_ros, 0, sizeof(m_ros));
- memset(m_drawer, 0, sizeof(m_drawer));
- memset(m_channel, 0, sizeof(m_channel));
- memset(m_gain, 0, sizeof(m_gain));
- memset(m_ped, 0, sizeof(m_ped));
- memset(m_lfn, 0, sizeof(m_lfn));
- memset(m_hfn, 0, sizeof(m_hfn));
- memset(m_noise_cov, 0, sizeof(m_noise_cov));
- memset(m_auto_corr, 0, sizeof(m_auto_corr));
-
CHECK( m_dqStatusKey.initialize() );
if (!m_eventInfoKey.key().empty()) {
@@ -436,7 +451,7 @@ StatusCode TileDigiNoiseCalibAlg::fillDigits (const TileDQstatus* theDQstatus) {
}
if (dsize > 0) {
m_ped[ros][drawer][chan][gain] += vdigits[0];
- m_SumPed2[ros][drawer][chan][gain] += vdigits[0] * vdigits[0];
+ m_sumPed2[ros][drawer][chan][gain] += vdigits[0] * vdigits[0];
if (dsize > 1) {
m_evt[ros][drawer][chan][gain]++;
@@ -444,7 +459,7 @@ StatusCode TileDigiNoiseCalibAlg::fillDigits (const TileDQstatus* theDQstatus) {
rmssamp = rmssamp / dsize - meansamp * meansamp;
rmssamp = (rmssamp > 0.0) ? sqrt(rmssamp * dsize / (dsize - 1)) : 0.0;
m_hfn[ros][drawer][chan][gain] += rmssamp;
- m_SumRms2[ros][drawer][chan][gain] += rmssamp * rmssamp;
+ m_sumRms2[ros][drawer][chan][gain] += rmssamp * rmssamp;
}
}
@@ -460,9 +475,9 @@ StatusCode TileDigiNoiseCalibAlg::fillDigits (const TileDQstatus* theDQstatus) {
for (int sample = 0; sample < m_nSamples; ++sample) {
for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
- m_MeanAmp[ros][drawer][chan_i][gain] += mean_tmp[chan_i][sample][gain];
+ m_meanAmp[ros][drawer][chan_i][gain] += mean_tmp[chan_i][sample][gain];
for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j)
- m_MeanAmp_ij[ros][drawer][chan_i][chan_j][gain] += mean_tmp[chan_i][sample][gain] * mean_tmp[chan_j][sample][gain];
+ m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] += mean_tmp[chan_i][sample][gain] * mean_tmp[chan_j][sample][gain];
}
}
}
@@ -508,8 +523,8 @@ void TileDigiNoiseCalibAlg::finalDigits() {
m_hfn[ros][drawer][chan][gain] /= nev;
if (nev > 1) {
- double PedRMS = m_SumPed2[ros][drawer][chan][gain] / nev - Ped * Ped;
- PedRMS = m_SumPed2[ros][drawer][chan][gain] / nev - Ped * Ped;
+ double PedRMS = m_sumPed2[ros][drawer][chan][gain] / nev - Ped * Ped;
+ PedRMS = m_sumPed2[ros][drawer][chan][gain] / nev - Ped * Ped;
PedRMS = (PedRMS > 0.0) ? sqrt(PedRMS * nev / (nev - 1)) : 0.0;
m_lfn[ros][drawer][chan][gain] = PedRMS;
}
@@ -547,9 +562,9 @@ void TileDigiNoiseCalibAlg::finalDigits() {
//replace m_evtNr with sqrt(m_evt[ch_i]*m_evt[ch_j])
for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
- m_MeanAmp[ros][drawer][chan_i][gain] /= m_evtNr * m_nSamples;
+ m_meanAmp[ros][drawer][chan_i][gain] /= m_evtNr * m_nSamples;
for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j)
- m_MeanAmp_ij[ros][drawer][chan_i][chan_j][gain] /= m_evtNr * m_nSamples;
+ m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] /= m_evtNr * m_nSamples;
}
double covar[48][48];
@@ -558,7 +573,7 @@ void TileDigiNoiseCalibAlg::finalDigits() {
for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j) {
- covar[chan_i][chan_j] = m_MeanAmp_ij[ros][drawer][chan_i][chan_j][gain] - m_MeanAmp[ros][drawer][chan_i][gain] * m_MeanAmp[ros][drawer][chan_j][gain];
+ covar[chan_i][chan_j] = m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] - m_meanAmp[ros][drawer][chan_i][gain] * m_meanAmp[ros][drawer][chan_j][gain];
if (chan_j < chan_i) {
mean_cov_ij += covar[chan_i][chan_j]; //LF: we take C_ij with its sign
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
index 6f02a6afcbf87619bf1f7d057ac3a979e99ceec1..8c7bcb34cdfcb5aeb425625c1db5d93d7be690fa 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
@@ -131,8 +131,6 @@ TileLaserTimingTool::TileLaserTimingTool(const std::string& type, const std::str
declareInterface<ITileCalibTool>( this );
declareProperty("TileCondToolTiming", m_tileToolTiming);
- //declareProperty("RawChannelContainer", m_rawChannelContainerName = "TileRawChannelFit");
- //declareProperty("DigitsContainer", m_digitsContainerName = "TileDigitsCnt");
declareProperty("NtupleID", m_ntupleID = "h3000");
declareProperty("FiberLightSpeed", m_fiberLightSpeed);
declareProperty("NSamples", m_nSamples = 9);
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileRawChNoiseCalibAlg.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileRawChNoiseCalibAlg.cxx
index 3bcb7a30d210d53bfc5a162abc0a3adf63e60069..799042d8ab323bd38983cccc3af4e8f7ed7fb5e2 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileRawChNoiseCalibAlg.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileRawChNoiseCalibAlg.cxx
@@ -107,64 +107,112 @@ TileRawChNoiseCalibAlg::TileRawChNoiseCalibAlg(const std::string& name, ISvcLoca
m_fillidx=false;
+ m_histAmp = new TH1F*[RCnum][5][64][48][2]();
+ m_histCellAmp = new TH1F*[2][64][4][17][6]();
+ m_evt = new int[5][64][48][2]();
+ m_ros = new uint8_t[5][64][48][2]();
+ m_drawer = new uint8_t[5][64][48][2]();
+ m_channel = new uint8_t[5][64][48][2]();
+ m_gain = new bool[5][64][48][2]();
+ m_rc_mean = new float[RCnum][5][64][48][2]();
+ m_rc_sigma = new float[RCnum][5][64][48][2]();
+ m_rc_av = new float[RCnum][5][64][48][2]();
+ m_rc_rms = new float[RCnum][5][64][48][2]();
+ m_rc_skewness = new float[RCnum][5][64][48][2]();
+ m_rc_kurtosis = new float[RCnum][5][64][48][2]();
+ m_rc_mean_err = new float[RCnum][5][64][48][2]();
+ m_rc_sigma_err = new float[RCnum][5][64][48][2]();
+ m_rc_chi2 = new float[RCnum][5][64][48][2]();
+ m_rc_ndf = new float[RCnum][5][64][48][2]();
+ m_rc_probC2 = new float[RCnum][5][64][48][2]();
+ m_rc_ggpar = new float[RCnum][5][64][48][2][8]();
+ m_rc_gsigma1 = new float[RCnum][5][64][48][2]();
+ m_rc_gsigma2 = new float[RCnum][5][64][48][2]();
+ m_rc_gnorm = new float[RCnum][5][64][48][2]();
+ m_rc_gchi2 = new float[RCnum][5][64][48][2]();
+ m_rc_gerrsigma1= new float[RCnum][5][64][48][2]();
+ m_rc_gerrsigma2 = new float[RCnum][5][64][48][2]();
+ m_rc_gerrnorm = new float[RCnum][5][64][48][2]();
+ m_rc_gcorrsigma1sigma2 = new float[RCnum][5][64][48][2]();
+
+ m_side = new bool[2][64][4][17][6]();
+ m_phi = new uint8_t[2][64][4][17][6]();
+ m_sample = new uint8_t[2][64][4][17][6]();
+ m_tower = new uint8_t[2][64][4][17][6]();
+ m_gg = new uint8_t[2][64][4][17][6]();
+ m_ecell_av = new float[2][64][4][17][6]();
+ m_ecell_rms= new float[2][64][4][17][6]();
+ m_ecell_hash= new uint32_t[2][64][4][17]();
+
+ m_cell_nch = new int[2][64][4][17][2]();
+ m_ecell_ene = new float[2][64][4][17][2]();
+ m_ggpar = new float[2][64][4][17][6][8]();
+ m_gsigma1 = new float[2][64][4][17][6]();
+ m_gsigma2 = new float[2][64][4][17][6]();
+ m_gnorm = new float[2][64][4][17][6]();
+ m_gchi2 = new float[2][64][4][17][6]();
+ m_gerrsigma1 = new float[2][64][4][17][6]();
+ m_gerrsigma2 = new float[2][64][4][17][6]();
+ m_gerrnorm = new float[2][64][4][17][6]();
+ m_gcorrsigma1sigma2 = new float[2][64][4][17][6]();
}
TileRawChNoiseCalibAlg::~TileRawChNoiseCalibAlg()
-{ }
+{
+ //delete[] m_histAmp;
+ //delete[] m_histCellAmp;
+ delete[] m_evt;
+ delete[] m_ros;
+ delete[] m_drawer;
+ delete[] m_channel;
+ delete[] m_gain;
+ delete[] m_rc_mean;
+ delete[] m_rc_sigma;
+ delete[] m_rc_av;
+ delete[] m_rc_rms;
+ delete[] m_rc_skewness;
+ delete[] m_rc_kurtosis;
+ delete[] m_rc_mean_err;
+ delete[] m_rc_sigma_err;
+ delete[] m_rc_chi2;
+ delete[] m_rc_ndf;
+ delete[] m_rc_probC2;
+ delete[] m_rc_ggpar;
+ delete[] m_rc_gsigma1;
+ delete[] m_rc_gsigma2;
+ delete[] m_rc_gnorm;
+ delete[] m_rc_gchi2;
+ delete[] m_rc_gerrsigma1;
+ delete[] m_rc_gerrsigma2;
+ delete[] m_rc_gerrnorm;
+ delete[] m_rc_gcorrsigma1sigma2;
+
+ delete[] m_side;
+ delete[] m_phi;
+ delete[] m_sample;
+ delete[] m_tower;
+ delete[] m_gg;
+ delete[] m_ecell_av;
+ delete[] m_ecell_rms;
+ delete[] m_ecell_hash;
+
+ delete[] m_cell_nch;
+ delete[] m_ecell_ene;
+ delete[] m_ggpar;
+ delete[] m_gsigma1;
+ delete[] m_gsigma2;
+ delete[] m_gnorm;
+ delete[] m_gchi2;
+ delete[] m_gerrsigma1;
+ delete[] m_gerrsigma2;
+ delete[] m_gerrnorm;
+ delete[] m_gcorrsigma1sigma2;
+}
/// Only array initialization is done here
/// All the helpers initialization is done at the first event
StatusCode TileRawChNoiseCalibAlg::initialize() {
- memset(m_rc_mean ,0, sizeof(m_rc_mean ));
- memset(m_rc_av ,0, sizeof(m_rc_av ));
- memset(m_rc_rms ,0, sizeof(m_rc_rms ));
- memset(m_rc_kurtosis ,0, sizeof(m_rc_kurtosis ));
- memset(m_rc_skewness ,0, sizeof(m_rc_skewness ));
- memset(m_rc_sigma ,0, sizeof(m_rc_sigma ));
- memset(m_rc_mean_err ,0, sizeof(m_rc_mean_err ));
- memset(m_rc_sigma_err ,0, sizeof(m_rc_sigma_err ));
- memset(m_rc_chi2 ,0, sizeof(m_rc_chi2 ));
- memset(m_rc_ndf ,0, sizeof(m_rc_ndf ));
- memset(m_rc_probC2 ,0, sizeof(m_rc_probC2 ));
- memset(m_ros ,0, sizeof(m_ros ));
- memset(m_drawer ,0, sizeof(m_drawer ));
- memset(m_channel ,0, sizeof(m_channel ));
- memset(m_gain ,0, sizeof(m_gain ));
-
- memset(m_rc_ggpar ,0, sizeof(m_rc_ggpar ));
- memset(m_rc_gsigma1 ,0, sizeof(m_rc_gsigma1 ));
- memset(m_rc_gsigma2 ,0, sizeof(m_rc_gsigma2 ));
- memset(m_rc_gnorm ,0, sizeof(m_rc_gnorm ));
- memset(m_rc_gchi2 ,0, sizeof(m_rc_gchi2 ));
- memset(m_rc_gerrsigma1,0, sizeof(m_rc_gerrsigma1));
- memset(m_rc_gerrnorm ,0, sizeof(m_rc_gerrnorm ));
- memset(m_rc_gerrsigma2,0, sizeof(m_rc_gerrsigma2));
- memset(m_rc_gcorrsigma1sigma2 ,0, sizeof(m_rc_gcorrsigma1sigma2 ));
-
-
- memset(m_ecell_av ,0, sizeof(m_ecell_av ));
- memset(m_ecell_rms ,0, sizeof(m_ecell_rms ));
- memset(m_ecell_hash ,0xFF, sizeof(m_ecell_hash ));
- memset(m_side ,0, sizeof(m_side ));
- memset(m_phi ,0, sizeof(m_phi ));
- memset(m_sample ,0, sizeof(m_sample ));
- memset(m_tower ,0, sizeof(m_tower ));
- memset(m_gg ,0, sizeof(m_gg ));
- memset(m_ggpar ,0, sizeof(m_ggpar ));
- memset(m_gsigma1 ,0, sizeof(m_gsigma1 ));
- memset(m_gsigma2 ,0, sizeof(m_gsigma2 ));
- memset(m_gnorm ,0, sizeof(m_gnorm ));
- memset(m_gchi2 ,0, sizeof(m_gchi2 ));
- memset(m_gerrsigma1 ,0, sizeof(m_gerrsigma1 ));
- memset(m_gerrnorm ,0, sizeof(m_gerrnorm ));
- memset(m_gerrsigma2 ,0, sizeof(m_gerrsigma2 ));
- memset(m_gcorrsigma1sigma2 ,0, sizeof(m_gcorrsigma1sigma2 ));
-// memset(gcorrsigma1norm ,0, sizeof(gcorrsigma1norm));
-// memset(gcorrsigma2norm ,0, sizeof(gcorrsigma2norm));
-
- memset(m_histAmp ,0, sizeof(m_histAmp ));
-
int nbin = 151;
float binwidth[2] = { 0.125, 0.25 }; // in ADC
float xmax[2] = { (float) nbin * binwidth[0] / 2.F, (float) nbin * binwidth[1] / 2.F }; // in ADC
@@ -192,7 +240,6 @@ StatusCode TileRawChNoiseCalibAlg::initialize() {
nbin = 301;
float cellbin[2] = { 80., 2.5 }; //in MeV
float xcellmax[2] = { (float) nbin * cellbin[0] / 2.F, (float) nbin * cellbin[1] / 2.F }; //in MeV
- memset(m_histCellAmp ,0, sizeof(m_histCellAmp ));
for (int side = 0; side < 2; side++) {
for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
@@ -304,8 +351,8 @@ StatusCode TileRawChNoiseCalibAlg::execute() {
StoreRunInfo(dqStatus); // done only once
}
- memset(m_ecell_ene ,0, sizeof(m_ecell_ene ));
- memset(m_cell_nch ,0, sizeof(m_cell_nch ));
+ memset(m_ecell_ene ,0, 2 * sizeof( *m_ecell_ene ));
+ memset(m_cell_nch ,0, 2 * sizeof( *m_cell_nch ));
m_cispar = dqStatus->cispar();
if (m_evtNr % 1000 == 0) ATH_MSG_INFO( " events processed so far " << m_evtNr );
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTOFTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTOFTool.cxx
index 7ee8a4568328a9e978d88adabd5e8d1a63fb95f3..828e8ef79cedff3a16eca9a298e18a5ae2b5c2fe 100755
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTOFTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTOFTool.cxx
@@ -22,7 +22,6 @@
TileTOFTool::TileTOFTool(const std::string& type, const std::string& name, const IInterface* pParent )
: AthAlgTool( type, name, pParent ),
m_tileID(nullptr),
- m_TimeCor(),
m_LBA_LBC(),
m_LBA_EBA(),
m_LBC_EBC(),
@@ -31,14 +30,22 @@ TileTOFTool::TileTOFTool(const std::string& type, const std::string& name, const
m_Nebc(),
m_LA_EA(0),
m_LA_LC(0),
- m_LA_EC(0),
- m_tcor(),
- m_Npair()
+ m_LA_EC(0)
{
declareInterface<ITileCalibTool>( this );
+
+ m_timeCor = new float[4][64]();
+ m_tcor = new float[4][32][32]();
+ m_nPair = new int[4][32][32]();
}
-TileTOFTool::~TileTOFTool() {}
+TileTOFTool::~TileTOFTool() {
+
+ delete[] m_timeCor;
+ delete[] m_tcor;
+ delete[] m_nPair;
+
+}
///////////////////////////////////////////////////////////
@@ -133,7 +140,7 @@ StatusCode TileTOFTool::execute()
for(int s=0; s<4; s++) {
for(int k=0; k<32; k++) {
for(int l=0; l<32; l++) {
- TIMECOR(k,l+32,s,s, m_Npair[s][k][l], m_tcor[s][k][l]);
+ TIMECOR(k,l+32,s,s, m_nPair[s][k][l], m_tcor[s][k][l]);
}
}
}
@@ -159,8 +166,8 @@ StatusCode TileTOFTool::finalizeCalculations()
for(int s=0; s<4; s++) {
for(int k=0; k<32; k++) {
for(int l=0; l<32; l++) {
- if(m_Npair[s][k][l]!=0) {
- m_tcor[s][k][l] = m_tcor[s][k][l]/m_Npair[s][k][l];
+ if(m_nPair[s][k][l]!=0) {
+ m_tcor[s][k][l] = m_tcor[s][k][l]/m_nPair[s][k][l];
}
}
}}
@@ -176,7 +183,7 @@ StatusCode TileTOFTool::finalizeCalculations()
for(int s=0; s<4; s++){
if(m_Neba[s]!=0) {
m_LBA_EBA[s] = m_LBA_EBA[s]/m_Neba[s];
- if(m_Npair[0][15][s+14]>5) {
+ if(m_nPair[0][15][s+14]>5) {
m_LA_EA = m_LA_EA + m_tcor[0][15][s+14] - m_LBA_EBA[s];
p0++;
}
@@ -184,7 +191,7 @@ StatusCode TileTOFTool::finalizeCalculations()
if(m_Nlbc[s]!=0) {
m_LBA_LBC[s] = m_LBA_LBC[s]/m_Nlbc[s];
- if(m_Npair[2][15][s+14]>5) {
+ if(m_nPair[2][15][s+14]>5) {
m_LA_LC = m_LA_LC + m_tcor[2][15][s+14] - m_LBA_LBC[s];
p2++;
}
@@ -192,7 +199,7 @@ StatusCode TileTOFTool::finalizeCalculations()
if(m_Nebc[s]!=0) {
m_LBC_EBC[s] = m_LBC_EBC[s]/m_Nlbc[s];
- if(m_Npair[2][15][s+14]>5) {
+ if(m_nPair[2][15][s+14]>5) {
m_LA_EC = m_LA_EC + m_LA_LC + m_tcor[3][15][s+14] - m_LBC_EBC[s];
p3++;
}
@@ -206,15 +213,15 @@ StatusCode TileTOFTool::finalizeCalculations()
// Calculation of time offsets wrt module 16 of each partition
int n2[4][64] = {{0}};
- memset( m_TimeCor, 0, sizeof(m_TimeCor) );
+ memset( m_timeCor, 0, 2 * sizeof(*m_timeCor) );
for(int s=0; s<4; s++){
- m_TimeCor[s][15] = 0.; n2[s][15] = 1;
+ m_timeCor[s][15] = 0.; n2[s][15] = 1;
for(int k=12; k<20; k++) {
- if(m_Npair[s][15][k]>5) {
- m_TimeCor[s][k+32] = -m_tcor[s][15][k];
+ if(m_nPair[s][15][k]>5) {
+ m_timeCor[s][k+32] = -m_tcor[s][15][k];
n2[s][k+32]=1;
}
}
@@ -223,155 +230,155 @@ StatusCode TileTOFTool::finalizeCalculations()
for(int k=12; k<15; k++) {
for(int l=16; l<20; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][k] += m_TimeCor[s][l+32] + m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][k] += m_timeCor[s][l+32] + m_tcor[s][k][l];
n2[s][k]++;
}
}
if(n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
for(int k=12; k<16; k++) {
for(int l=20; l<24; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][l+32] += m_TimeCor[s][k] - m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][l+32] += m_timeCor[s][k] - m_tcor[s][k][l];
n2[s][l+32]++;
}
}
}
for(int k=52; k<56; k++) {
if(n2[s][k]>0) {
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
}
for(int k=8; k<12; k++) {
for(int l=20; l<24; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][k] += m_TimeCor[s][l+32] + m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][k] += m_timeCor[s][l+32] + m_tcor[s][k][l];
n2[s][k]++;
}
}
if(n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
for(int k=8; k<12; k++) {
for(int l=24; l<28; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][l+32] += m_TimeCor[s][k] - m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][l+32] += m_timeCor[s][k] - m_tcor[s][k][l];
n2[s][l+32]++;
}
}
}
for(int k=56; k<60; k++) {
if(n2[s][k]>0) {
- m_TimeCor[s][k] /=n2[s][k];
+ m_timeCor[s][k] /=n2[s][k];
}
}
for(int k=0; k<8; k++) {
for(int l=24; l<28; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][k] += m_TimeCor[s][l+32] + m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][k] += m_timeCor[s][l+32] + m_tcor[s][k][l];
n2[s][k]++;
}
}
if (n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
for(int k=4; k<8; k++) {
for(int l=28; l<32; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][l+32] += m_TimeCor[s][k] - m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][l+32] += m_timeCor[s][k] - m_tcor[s][k][l];
n2[s][l+32]++;
}
}
}
for(int k=60; k<64; k++) {
if(n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
// Path to calculate all time offsets for modules in region x < 0
for(int k=16; k<20; k++) {
for(int l=12; l<16; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][k] += m_TimeCor[s][l+32] + m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][k] += m_timeCor[s][l+32] + m_tcor[s][k][l];
n2[s][k]++;
}
}
if(n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
for(int k=16; k<20; k++) {
for(int l=8; l<12; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][l+32] += m_TimeCor[s][k] - m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][l+32] += m_timeCor[s][k] - m_tcor[s][k][l];
n2[s][l+32]++;
}
}
}
for(int k=40; k<44; k++) {
if(n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
for(int k=20; k<24; k++){
for(int l=8; l<12; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][k] += m_TimeCor[s][l+32] + m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][k] += m_timeCor[s][l+32] + m_tcor[s][k][l];
n2[s][k]++;
}
}
if(n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
for(int k=20; k<24; k++) {
for(int l=4; l<8; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][l+32] += m_TimeCor[s][k] - m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][l+32] += m_timeCor[s][k] - m_tcor[s][k][l];
n2[s][l+32]++;
}
}
}
for(int k=36; k<40; k++) {
if(n2[s][k]>0) {
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
}
for(int k=24; k<32; k++) {
for(int l=4; l<8; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][k] += m_TimeCor[s][l+32] + m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][k] += m_timeCor[s][l+32] + m_tcor[s][k][l];
n2[s][k]++;
}
}
if(n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
for(int k=24; k<28; k++) {
for(int l=0; l<4; l++) {
- if(m_Npair[s][k][l]>5) {
- m_TimeCor[s][l+32] += m_TimeCor[s][k] - m_tcor[s][k][l];
+ if(m_nPair[s][k][l]>5) {
+ m_timeCor[s][l+32] += m_timeCor[s][k] - m_tcor[s][k][l];
n2[s][l+32]++;
}
}
}
for(int k=32; k<36; k++) {
if(n2[s][k]>0)
- m_TimeCor[s][k] /= n2[s][k];
+ m_timeCor[s][k] /= n2[s][k];
}
for(int l=0; l<64; l++) {
- ATH_MSG_INFO ( "Partition: " << s << " Module: " << l+1 << " TimeCor: " << m_TimeCor[s][l] << " n: " << n2[s][l] );
+ ATH_MSG_INFO ( "Partition: " << s << " Module: " << l+1 << " TimeCor: " << m_timeCor[s][l] << " n: " << n2[s][l] );
}
} //end of loop over different partitions
@@ -383,7 +390,7 @@ StatusCode TileTOFTool::writeNtuple(int runNumber, int runType, TFile * rootFile
ATH_MSG_INFO ( "writeNtuple(" << runNumber << "," << runType << "," << rootFile << ")" );
TTree *t = new TTree("TOF", "TOF");
- t->Branch("Time_Offset", m_TimeCor, "Time_Offset[4][64]/F");
+ t->Branch("Time_Offset", m_timeCor, "Time_Offset[4][64]/F");
t->Branch("eba16_lba16", &m_LA_EA, "eba16_lba16/F");
t->Branch("lbc16_lba16", &m_LA_LC, "lbc16_lba16/F");
t->Branch("ebc16_lba16", &m_LA_EC, "ebc16_lba16/F");
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
index 9ee14b0bd7ec2b2c2085c0cd850b9dce2371073b..be7e29927381bbc015cc5d9f4fc243f669a5a96f 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
@@ -56,24 +56,6 @@ TileTriggerDefaultCalibTool::TileTriggerDefaultCalibTool(const std::string& type
, m_tileID(nullptr)
, m_tileCablingService(nullptr)
, m_tileToolEmscale("TileCondToolEmscale")
- , m_meanTile()
- , m_rmsTile()
- , m_meanTileDAC()
- , m_rmsTileDAC()
- , m_ietaTile()
- , m_iphiTile()
- , m_ipmtTile()
- , m_nEvtTile()
- , m_meanL1Calo()
- , m_rmsL1Calo()
- , m_meanL1CaloDAC()
- , m_rmsL1CaloDAC()
- , m_ietaL1Calo()
- , m_iphiL1Calo()
- , m_ipmtL1Calo()
- , m_nEvtL1Calo()
- , m_meanTileL1Calo()
- , m_rmsTileL1Calo()
, m_DACvalue(0)
, m_charge(0)
, m_ipmt(0)
@@ -95,10 +77,50 @@ TileTriggerDefaultCalibTool::TileTriggerDefaultCalibTool(const std::string& type
declareProperty("TileCondToolEmscale", m_tileToolEmscale);
declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
// declareProperty("L1TriggerTowerTool", m_ttTool);
+
+ m_meanTile = new float[5][64][48]();
+ m_rmsTile = new float[5][64][48]();
+ m_meanTileDAC = new float[5][64][48]();
+ m_rmsTileDAC = new float[5][64][48]();
+ m_ietaTile = new int[5][64][48]();
+ m_iphiTile = new int[5][64][48]();
+ m_ipmtTile = new int[5][64][48]();
+ m_nEvtTile = new int[5][64][48]();
+
+ m_meanL1Calo = new float[5][64][48]();
+ m_rmsL1Calo = new float[5][64][48]();
+ m_meanL1CaloDAC = new float[5][64][48]();
+ m_rmsL1CaloDAC = new float[5][64][48]();
+ m_ietaL1Calo = new int[5][64][48]();
+ m_iphiL1Calo = new int[5][64][48]();
+ m_ipmtL1Calo = new int[5][64][48]();
+ m_nEvtL1Calo = new int[5][64][48]();
+
+ m_meanTileL1Calo = new float[5][64][48]();
+ m_rmsTileL1Calo = new float[5][64][48]();
}
TileTriggerDefaultCalibTool::~TileTriggerDefaultCalibTool()
-{}
+{
+ delete[] m_meanTile;
+ delete[] m_rmsTile;
+ delete[] m_meanTileDAC;
+ delete[] m_rmsTileDAC;
+ delete[] m_ietaTile;
+ delete[] m_iphiTile;
+ delete[] m_ipmtTile;
+ delete[] m_nEvtTile;
+ delete[] m_meanL1Calo;
+ delete[] m_rmsL1Calo;
+ delete[] m_meanL1CaloDAC;
+ delete[] m_rmsL1CaloDAC;
+ delete[] m_ietaL1Calo;
+ delete[] m_iphiL1Calo;
+ delete[] m_ipmtL1Calo;
+ delete[] m_nEvtL1Calo;
+ delete[] m_meanTileL1Calo;
+ delete[] m_rmsTileL1Calo;
+}
StatusCode TileTriggerDefaultCalibTool::initialize()
{