onlinemonitor/rocmonitor/TPedestalExtractor.cxx (r4864/r3724)

Go to the documentation of this file.

#include "TPedestalExtractor.h"

#include <stdio.h>
#include <fstream>
#include "TGo4Log.h"

#include "TMath.h"

//----------------------------------------------------------------------------

const Char_t * TPedestalExtractor::kPedFileFormat = "%d%d%d%f%f";

TPedestalExtractor::TPedestalExtractor( Int_t rocArrSize, Int_t nxArrSize, roc::SysMessageUserTypes initialState, Int_t nChannels, Int_t nAdcBins, Double_t adcMin, Double_t adcMax )
{
   TGo4Log::Info("Creating instance of TPedestalExtractor");
        // Check argument validity:
        if( rocArrSize < 0 || nxArrSize < 0 || nChannels < 0 || nAdcBins < 0 || adcMin > adcMax ) {
                PrintLog( "In TPedestalExtractor::TPedestalExtractor: Invalid argument", 0 );
                fRocArrSize = 0;
                fNxArrSize = 0;
                fNChannels = 0;
                fNAdcBins = 0;
                fAdcMin = 0.;
                fAdcMax = 0.;           
                return;
        }

        fVerbose = 0;
        fExttrigCalibrPeriod = 10000000000LL;
        fRocArrSize = rocArrSize;
        fNxArrSize = nxArrSize;
        fNChannels = nChannels;
        fNAdcBins = nAdcBins;
        fAdcMin = adcMin;
        fAdcMax = adcMax;

        fLastCalibrTime.resize( fRocArrSize );
        fLastHitTime.resize( fRocArrSize );

        for(Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++) {
                fLastCalibrTime[ iRoc ] = 0;
                fLastHitTime[ iRoc ] = 0;
        }

        fState = new roc::SysMessageUserTypes[fRocArrSize];
        fPrevState = new roc::SysMessageUserTypes[fRocArrSize];
        fIsExtracted = new Bool_t[ fRocArrSize ];
        for(Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++) {
                fState[iRoc] = initialState;
                fPrevState[iRoc] = roc::SYSMSG_USER_RECONFIGURE;
                fIsExtracted[ iRoc ] = kFALSE;
        }

        fBaselines = new TH1F***[fRocArrSize];
        fPedestals = new Float_t**[fRocArrSize];
        fWidths = new Float_t**[fRocArrSize];
        for(Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++) {
                fBaselines[iRoc] = new TH1F**[fNxArrSize];
                fPedestals[iRoc] = new Float_t*[fNxArrSize];
                fWidths[iRoc] = new Float_t*[fNxArrSize];
                for(Int_t iNx = 0; iNx < fNxArrSize; iNx++) {
                        fBaselines[iRoc][iNx] = new TH1F*[fNChannels];
                        fPedestals[iRoc][iNx] = new Float_t[fNChannels];
                        fWidths[iRoc][iNx] = new Float_t[fNChannels];
                        for(Int_t iChannel = 0; iChannel < fNChannels; iChannel++) {
                                fBaselines[iRoc][iNx][iChannel] = new TH1F(Form("hPedR%dN%dCh%d", iRoc, iNx, iChannel),"", nAdcBins, adcMin, adcMax );
                                // avoid ROOT cleanup for histograms
                                fBaselines[iRoc][iNx][iChannel]->SetDirectory(0);
                                fPedestals[iRoc][iNx][iChannel] = kInvalidPedestalValue;
                                fWidths[iRoc][iNx][iChannel] = kInvalidWidthValue;
                        }
                }
        }
        fPrintedDataNotTimeSorted = kFALSE;
}

TPedestalExtractor::~TPedestalExtractor()
{
        // If fHistograms should have been created in the constructor, together with fPedestals and fWidths.
        if(fBaselines == 0) {
                TGo4Log::Error("Error in TPedestalExtractor::~TPedestalExtractor(): fHistograms is 0; Probably the default constructor was used, which is not supported");
                return;
        }
        for(Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++) {
                for(Int_t iNx = 0; iNx < fNxArrSize; iNx++) {
                        for(Int_t iChannel = 0; iChannel < fNChannels; iChannel++) {
                                delete fBaselines[iRoc][iNx][iChannel];
                                fBaselines[iRoc][iNx][iChannel] = 0;
                        }
                        delete [] fBaselines[iRoc][iNx];
                        delete [] fPedestals[iRoc][iNx];
                        delete [] fWidths[iRoc][iNx];
                }
                delete [] fBaselines[iRoc];
                delete [] fPedestals[iRoc];
                delete [] fWidths[iRoc];
        }
        delete [] fBaselines;
        delete [] fPedestals;
        delete [] fWidths;

        delete [] fState;
        delete [] fPrevState;
        delete [] fIsExtracted;
}


void TPedestalExtractor::AddHit( Int_t iRoc, Int_t iNx, Int_t iChannel, Int_t adc )
{
        if( IsValid( iRoc, iNx, iChannel ) ) {
                fBaselines[iRoc][iNx][iChannel]->Fill( adc );
        }
}


void TPedestalExtractor::ChangeState( roc::SysMessageUserTypes const & newState )
{
        for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++ ) {
                ChangeState( iRoc, newState );
        }
}


void TPedestalExtractor::ChangeState( Int_t rocId, roc::SysMessageUserTypes const & newState )
{
        fPrevState[rocId] = fState[rocId];
        fState[rocId] = newState;
}


void TPedestalExtractor::PrintLog(const char* message, Int_t minVerbose ) const
{
        if( fVerbose >= minVerbose )
                printf( "%s\n", message );
}


uint64_t TPedestalExtractor::GetLastCalibrTime( Int_t rocId ) const
{
        return fLastCalibrTime.at( rocId );
}


void TPedestalExtractor::SetVerbose( Int_t verbose )
{
        fVerbose = verbose;
}


Int_t TPedestalExtractor::GetVerbose() const
{
        return fVerbose;
}



/*
 * Check if the first line of file pedFileName matches the format kPedFileFormat of the pedestal file.
 * Returns kFALSE if the file can not be opened.
 */
Bool_t TPedestalExtractor::IsLooksLikeNewPedestalFileFormat(const char* pedFileName ) const
{
   if ((pedFileName==0) || (strlen(pedFileName)==0)) return kFALSE;

   FILE * pedFile = fopen( pedFileName, "r" );

   if (!pedFile) return kFALSE;

   Bool_t retValue = kFALSE;

   Int_t dummyRoc = 0, dummyNx = 0, dummyCh = 0;
   Float_t dummyPed = 0, dummyWidht = 0;
   if( 5 == fscanf( pedFile, kPedFileFormat, &dummyRoc, &dummyNx, &dummyCh, &dummyPed, &dummyWidht ) ) {
      retValue = kTRUE;
   }
   fclose(pedFile);

   return retValue;
}



uint64_t TPedestalExtractor::GetSelftrigCalibrPeriod() const
{
        return fExttrigCalibrPeriod;
}



void TPedestalExtractor::SetExttrigCalibrPeriod( uint64_t period )
{
        fExttrigCalibrPeriod = period;
}


/*
 * Returns rocId which' state has changed, or -1 if none.
 */
Int_t TPedestalExtractor::WatchState( roc::Message const & msg )
{
        uint16_t rocId  = msg.getRocNumber();
        if( rocId >= fRocArrSize) {
                return -1;
        }
        uint8_t type = msg.getMessageType();

        if( type == roc::MSG_SYS ) {
                if( msg.getSysMesType() == roc::SYSMSG_USER ) {
                        uint32_t userMessageData = msg.getSysMesData();
                        if( userMessageData == roc::SYSMSG_USER_CALIBR_ON
                                        || userMessageData == roc::SYSMSG_USER_CALIBR_OFF
                                        || userMessageData == roc::SYSMSG_USER_RECONFIGURE ) {
                                ChangeState( rocId, ( roc::SysMessageUserTypes )userMessageData );
                        }
                        return rocId;
                }
        }
        return -1;
}


/*
 * Obsolete. Kept for compatibility.
 */
void TPedestalExtractor::WatchPedestalMessages( roc::Message const & msg, Long64_t const fullTime )
{
        ExtractAutocalibrStream( msg, fullTime );
}


/*
 * Identifies the calibration data among all other ROC messages, acquires it,
 * and invokes the calibration. Uses calibration markers, such as
 * roc::SYSMSG_USER_CALIBR_ON, roc::SYSMSG_USER_CALIBR_OFF and
 * roc::SYSMSG_USER_RECONFIGURE, to identify the calibration data.
 *
 * Data is to be passed via the msg argument. The user may pass absolutely all
 * ROC messages, without any preselection, to this function -- the function will
 * identify the calibration data itself.
 *
 * All ROCs are monitored independently. Data samples where only some of the ROCs
 * have calibration are also accepted (make sure then to put the ROCs without
 * calibration to the roc::SYSMSG_USER_RECONFIGURE state, so that the data from
 * them is not acquired).
 *
 * Whenever the roc::SYSMSG_USER_CALIBR_ON marker is received, all the
 * previously acquired calibration data is discarded. All data which comes
 * afterwards is acquired for the next calibration, until roc::SYSMSG_USER_RECONFIGURE
 * is received. Calibration is invoked on receiving a roc::SYSMSG_USER_CALIBR_OFF
 * message. If a roc::SYSMSG_USER_CALIBR_OFF message is received without a foregoing
 * roc::SYSMSG_USER_CALIBR_ON, an error is generated, and the ROC is switched to
 * roc::SYSMSG_USER_RECONFIGURE state.
 *
 * Return codes:
 *              0 - message processed successfully
 *              1 - roc id >= rocArrSize
 *              2 - CALIBR_OFF received without foregoing CALIBR_ON
 */
Int_t TPedestalExtractor::ExtractAutocalibrStream( roc::Message const & msg, uint64_t fullTime )
{
        uint16_t rocId  = msg.getRocNumber();
        if( rocId >= fRocArrSize) {
                return 1; // No need to generate an error -- it's normal to work with only some of the ROCs
        }
        uint8_t type = msg.getMessageType();

        if( type == roc::MSG_SYS ) {
                if( msg.getSysMesType() == roc::SYSMSG_USER ) {
                        switch( msg.getSysMesData() ) {
                                case roc::SYSMSG_USER_CALIBR_ON: {
                                        ResetCalibrData( rocId );
                                        ChangeState( rocId, roc::SYSMSG_USER_CALIBR_ON );
                                        PrintLog( Form( "CALIBR_ON on ROC %d", rocId), 1 );
                                        return 0;
                                }
                                case roc::SYSMSG_USER_CALIBR_OFF: {
                                        if( fPrevState[rocId] != roc::SYSMSG_USER_CALIBR_ON ) {
                                                ChangeState( rocId, roc::SYSMSG_USER_RECONFIGURE );
                                                PrintLog( Form("WARNING in TPedestalExtractor::WatchPedestalMessages: On ROC %d : CALIBR_OFF message appeared without CALIBR_ON before. Switching to RECONFIGRE.", rocId ), 0 );
                                                return 2;
                                        }
                                        ChangeState( rocId, roc::SYSMSG_USER_CALIBR_OFF );
                                        Extract( rocId );
                                        fLastCalibrTime[ rocId ] = fLastHitTime[ rocId ];
                                        PrintLog( Form( "CALIBR_OFF on ROC %d", rocId), 1 );
                                        return 0;
                                }
                                case roc::SYSMSG_USER_RECONFIGURE: {
                                        ChangeState( rocId, roc::SYSMSG_USER_RECONFIGURE );
                                        PrintLog( Form( "CALIBR_RECONFIGURE on ROC %d", rocId), 1 );
                                        return 0;
                                }
                        }
                }
        }

        if( type == roc::MSG_HIT && fState[rocId] == roc::SYSMSG_USER_CALIBR_ON ) {
                AddHit( rocId,  msg.getNxNumber(), msg.getNxChNum(), msg.getNxAdcValue() );
                fLastHitTime[ rocId ] = fullTime;
        }
        return 0;
}


/*
 * Extract baseline positions (pedestals) and widths (TODO: not yet implemented) from data,
 * where most of the hits have 0 amplitude (for instance, data taken with external trigger).
 * The data is divided on slices fExttrigCalibrPeriod nanoseconds long. Pedestals and
 * widths are extracted from data within one slice, and the result is granted to the user
 * for the time of the next slice. Therefore fExttrigCalibrPeriod must be set correctly.
 *
 * Data is to be passed via the msg argument. Correct fullTime is necessary for the time-slicing.
 */
Int_t TPedestalExtractor::ExtractExttrigStream( roc::Message const & msg, uint64_t fullTime )
{
        uint16_t rocId  = msg.getRocNumber();
        if( ! IsRocValid( rocId ) ) {
                return 1; // => rocId >= fRocArrSize -- it's ok to work with only a fraction of the ROCs, no need to generate an error.
        }

        if( msg.getMessageType() == roc::MSG_HIT ) {
                AddHit( rocId,  msg.getNxNumber(), msg.getNxChNum(), msg.getNxAdcValue() );
                if( fLastCalibrTime[ rocId ] == 0 ) {
                        fLastCalibrTime[ rocId ] = fullTime;
                }

                if( fullTime >= fLastCalibrTime[ rocId ] ) {
                        if( fullTime > fLastCalibrTime[ rocId ] + fExttrigCalibrPeriod ) {
                // printf( "In TPedestalExtractor::ExtractExttrigStream: Extracting pedestals...\n" );
                PrintLog( Form( "TPedestalExtractor::ExtractExttrigStream: Recalibrating ROC %d at %lu ns", rocId, (long unsigned) fullTime ), 1 );
                                Extract( rocId );
                                ResetCalibrData( rocId );
                                fLastCalibrTime[ rocId ] = fullTime;
                                // Print();
                        }
                }
                else {
                    if( ! fPrintedDataNotTimeSorted ) {
                        PrintLog( "Warning in TPedestalExtractor::ExtractExttrigStream: Data is not time-sorted!", 0 );
                        fPrintedDataNotTimeSorted = kTRUE;
                        // PrintLog( Form( "FullTs: %d", fullTime ), 0 );
                        // msg.printData( roc::msg_print_Human );
                    }
                }
        }
        return 0;
}



Int_t TPedestalExtractor::ExtractAutocalibrLmd( std::string lmdFileName, roc::SysMessageUserTypes initialState, Int_t skipCalibrIterations )
{
        ResetCalibrData();
        ResetCalibrResults();
        ChangeState( roc::SYSMSG_USER_RECONFIGURE );
        ChangeState( initialState );

        std::vector< Int_t > calibrIteration;
        calibrIteration.resize( fRocArrSize );
        calibrIteration.assign( fRocArrSize, 0 );

        std::vector< Bool_t > rocCalibrated;
        rocCalibrated.resize( fRocArrSize );
        rocCalibrated.assign( fRocArrSize, ( initialState == roc::SYSMSG_USER_CALIBR_ON ) ? 1 : 0 );

        roc::Iterator calibrIter( lmdFileName.c_str() );

        while( calibrIter.next() ) {
                roc::Message const & msg = calibrIter.msg();
                Int_t rocId = msg.getRocNumber();
                uint8_t msgType = msg.getMessageType();

                Bool_t doCheckCalibrDone = kFALSE;
                if( msgType == roc::MSG_SYS ) {
                        if( msg.getSysMesType() == roc::SYSMSG_USER ) {
                                if( msg.getSysMesData() == roc::SYSMSG_USER_CALIBR_ON ) {
                                        calibrIteration[ rocId ]++;
                                }
                                doCheckCalibrDone = kTRUE;
                        }
                }

                if( calibrIteration[ rocId ] == skipCalibrIterations + 1 ) {
                        ExtractAutocalibrStream( msg, calibrIter.getMsgFullTime() );
                        if( GetState( rocId ) == roc::SYSMSG_USER_CALIBR_OFF ) {
                                rocCalibrated[ rocId ] = kTRUE;
                        }
                }

                if( doCheckCalibrDone ) {
                        Bool_t allRocsCalibrated = kTRUE;
                        for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++  ) {
                                allRocsCalibrated = allRocsCalibrated && rocCalibrated[ iRoc ];
                        }
                        if( allRocsCalibrated ) {
                                return 0;
                        }
                }
        }

        if( fVerbose >= 0 ) {
                printf( "In TPedestalExtractor::ExtractAutocalibrLmd: Data sample is over, while not all ROCs were calibrated." );
                printf( "\t\t Non-calibrated ROCs: " );
                for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++ ) {
                        if( ! rocCalibrated[ iRoc ] ) {
                                printf( " %d ", iRoc );
                        }
                }
                printf( "\n" );
        }
        return 1;
}



//Int_t TPedestalExtractor::ExtractAutocalibrRoot( std::string rootFileName, Int_t calibrIteration )
//{
//
//}


//Int_t TPedestalExtractor::ExtractExttrigLmd( std::string lmdFileName, Float_t startTime, Float_t finishTime )
//{
//
//}

// * startTime and finishTime - w.r.t. beginning of the file
// * fTreePathName must be set correctly.
// */
//Int_t TPedestalExtractor::ExtractExttrigRoot( std::string rootFileName, uint64_t startTime, uint64_t finishTime )
//{
//      uint64_t fileBeginning = 0;
//      uint64_t currTime = 0;
//      TFile inputFile( rootFileName.c_str(), "read" );
//      TTree * tree = dynamic_cast< TTree * >( inputFile.Get( treePathName.c_str() ) );
//
//      TRocData* rocData= new TRocData();
//      tree->SetBranchAddress("ROC00.", &rocData);
//      tree->SetBranchStatus("*",0);
//      tree->SetBranchStatus("ROC00.*",1);
//
//      Int_t nEntries = tree->GetEntries();
//      for( Int_t iEntry = 0; iEntry < nEntries; ++iEntry ) {
//              tree->GetEntry( iEntry );
//              Int_t nMsg= rocData->fExtMessages.size();
//              for( Int_t iMsg = 0; iMsg < nMsg; iMsg++ ) {
//                      TRocMessageExtended msgExt = rocData->fExtMessages.at( iMsg );
//                      roc::Message rocMsg = msgExt.GetRocMessage();
//                      uint8_t msgType = rocMsg.getMessageType();
//                      if( msgType == roc::MSG_HIT ) {
//                              currTime = msgExt.GetFullTime();
//                              if( fileBeginning == 0 ) {
//                                      fileBeginning = currTime;
//                              }
//
//                              if( currTime > fileBeginning + startTime ) {
//                                      AddHit( rocMsg.getRocNumber(), rocMsg.getNxNumber(), rocMsg.getNxChNum(), rocMsg.getNxAdcValue() );
//                              }
//                      }
//              }
//              if( currTime > fileBeginning + finishTime ) {
//                      break;
//              }
//      }
//      Extract();
//      printf("Pedestals extracted\n");
//      return 0;
//}



void TPedestalExtractor::Extract()
{
        for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++ ) {
                Extract( iRoc );
        }
}



void TPedestalExtractor::Extract( Int_t rocId )
{
        if( IsRocValid( rocId ) ) {
                for(Int_t iNx = 0; iNx < fNxArrSize; iNx++) {
                        for(Int_t iChannel = 0; iChannel < fNChannels; iChannel++) {
                                Extract( fBaselines[rocId][iNx][iChannel], fPedestals[rocId][iNx][iChannel], fWidths[rocId][iNx][iChannel] );
                        }
                }
                fIsExtracted[ rocId ] = kTRUE;
                //printf( "In TPedestalExtractor::Extract( Int_t rocId = %d )\n", rocId );
                //Print( rocId );
        }
}



void TPedestalExtractor::Extract(TH1 * hist, Float_t & pedestal, Float_t & width )
{
   pedestal = kInvalidPedestalValue;
   width = kInvalidWidthValue;
   if( ! hist ) {
      printf("In TPedestalExtractor::Extract: No histogram received\n");
      return;
   }

   if( hist->GetEntries() < kEntriesMin ) {
           // It's normal that some channels have no data (e.g. masked channels). No error message has to be written.
           // printf( "In TPedestalExtractor::Extract: hist contains %f entries\n", hist->GetEntries() );
           return;
   }

   Int_t medianBin = 1;

   Double_t* integral = hist->GetIntegral();
   while( integral[medianBin + 1] <= 0.5 ) {
      medianBin++;
   }
   pedestal = hist->GetXaxis()->GetBinCenter( medianBin );

   Float_t sum = 0;
   Float_t sum2 = 0;
   Float_t sumCounts = 0;
   for( Int_t iBin = 1; iBin <= hist->GetNbinsX(); iBin++ )
   {
           Float_t nCounts = hist->GetBinContent( iBin );
           Float_t diff = hist->GetBinCenter( iBin ) - pedestal;
           sum += nCounts * diff;
           sum2 += nCounts * diff * diff;
           sumCounts += nCounts;
   }
   width = TMath::Sqrt( sum2 / sumCounts - sum / sumCounts * sum / sumCounts );
}


/*
 * Reset the acquired baseline data of all ROCs.
 * Does not change the results of pedestal extraction.
 */
void TPedestalExtractor::ResetCalibrData()
{
        for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++ ) {
                ResetCalibrData( iRoc );
        }
}


/*
 * Reset the acquired baseline data of the specified ROCs.
 * Does not change the results of pedestal extraction.
 */
void TPedestalExtractor::ResetCalibrData( Int_t rocId )
{
        if( IsRocValid( rocId ) ) {
                for(Int_t iNx = 0; iNx < fNxArrSize; iNx++) {
                        for(Int_t iChannel = 0; iChannel < fNChannels; iChannel++) {
                                fBaselines[rocId][iNx][iChannel]->Reset();
                        }
                }
        }
        else {
                PrintLog( Form("Warning in TPedestalExtractor::ResetCalibrData: rocId %d is not valid", rocId), 1 );
        }
}


/*
 * Reset results of pedestal and baseline width extraction on all ROCs.
 * Does not affect the baseline data.
 */
void TPedestalExtractor::ResetCalibrResults()
{
        {
                for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++ ) {
                        ResetCalibrResults( iRoc );
                }
        }
}


/*
 * Reset results of pedestal and baseline width extraction on ROC rocId.
 * Does not affect the baseline data.
 */
void TPedestalExtractor::ResetCalibrResults( Int_t rocId )
{
        if( IsRocValid( rocId ) ) {
                for(Int_t iNx = 0; iNx < fNxArrSize; iNx++) {
                        for(Int_t iChannel = 0; iChannel < fNChannels; iChannel++) {
                                fPedestals[rocId][iNx][iChannel] = kInvalidPedestalValue;
                                fWidths[rocId][iNx][iChannel] = kInvalidWidthValue;
                        }
                }
                fIsExtracted[rocId] = kFALSE;
        }
        else {
                PrintLog( Form("Warning in TPedestalExtractor::ResetCalibrResults: rocId %d is not valid", rocId), 1 );
        }
}


void TPedestalExtractor::ResetLastCalibrTime()
{
        {
                for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++ ) {
                        ResetLastCalibrTime( iRoc );
                }
        }
}



void TPedestalExtractor::ResetLastCalibrTime( Int_t rocId )
{
        if( IsRocValid( rocId ) ) {
                fLastCalibrTime[ rocId ] = 0;
        }
        else {
                PrintLog( Form("Warning in TPedestalExtractor::ResetLastCalibrTime: rocId %d is not valid", rocId), 1 );
        }
}



Float_t TPedestalExtractor::GetPedestal( Int_t roc, Int_t nx, Int_t channel ) const {
        if( IsValid( roc, nx, channel ) ) {
                return fPedestals[roc][nx][channel];
        }
        else {
                printf("ERROR in TPedestalExtractor::GetPedestal: Invalid arguments: roc=%d nx=%d channel=%d", roc, nx, channel );
                return kInvalidPedestalValue;
        }
}


Float_t TPedestalExtractor::GetWidth( Int_t roc, Int_t nx, Int_t channel ) const {
        if( IsValid( roc, nx, channel ) ) {
                return fWidths[roc][nx][channel];
        }
        else {
                printf("ERROR in TPedestalExtractor::GetWidthInvalid arguments: roc=%d nx=%d channel=%d", roc, nx, channel );
                return kInvalidPedestalValue;
        }
}




TH1F * TPedestalExtractor::GetHistogram( Int_t roc, Int_t nx, Int_t channel )
{
        if( IsValid( roc, nx, channel ) ) {
                return fBaselines[ roc ][ nx ][ channel ];
        }
        return 0;
}



TH2F * TPedestalExtractor::GetHist2DCopy( Int_t roc, Int_t nx )
{
        TH2F * hist = new TH2F( "hPedestals2D", "hPedestals2D", fNChannels, 0, fNChannels, fNAdcBins, fAdcMin, fAdcMax );
        Long64_t nEntries = 0;
        for( Int_t iCh = 0; iCh < fNChannels; iCh++ ) {
                for( Int_t iAdcBin = 1; iAdcBin < fNAdcBins; iAdcBin++ ) {
                        Long64_t nEntriesBin = GetHistogram( roc, nx, iCh )->GetBinContent( iAdcBin );
                        hist->SetBinContent( iCh + 1, iAdcBin, nEntriesBin );
                        nEntries += nEntriesBin;
                }
        }
        hist->SetEntries( nEntries );
        return hist;
}



Bool_t TPedestalExtractor::IsExtracted( Int_t roc ) const
{
        if( IsRocValid( roc ) ) {
                return( fIsExtracted[ roc ] );
        }
        else {
                printf( "Error in TPedestalExtractor::IsExtracted: Roc %d is not valid\n", roc );
        }
        return kFALSE;
}



Bool_t TPedestalExtractor::IsOneExtracted() const
{
        for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++ ) {
                if( fIsExtracted[ iRoc ] ) return kTRUE;
        }
        return kFALSE;
}



Bool_t TPedestalExtractor::IsAllExtracted() const
{
        for( Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++ ) {
                if( ! fIsExtracted[ iRoc ] ) return kFALSE;
        }
        return kTRUE;
}



/*
 * Expects a text file with pedestals in format:
 *    roc  nxyter  channel  pedestal_position  pedestal_width
 * Checks if the first line of the file matches the expected format,
 * and if not -- tries to interpret the file as in the old format:
 *    pedestal_position
 * with all pedestals stored in the order from the first one till the last
 *
 */
void TPedestalExtractor::LoadFromFile( Char_t const * fileName )
{

    if( IsLooksLikeNewPedestalFileFormat( fileName ) ) {
        FILE * pedFile = fopen( fileName, "r" );
        if( ! pedFile ) {
            PrintLog( Form("Pedestal file %s not found\n", fileName) );
            return;
        }
        Int_t roc, nx, ch;
        Float_t ped, width;
        while( 5 == fscanf( pedFile, kPedFileFormat, &roc, &nx, &ch, &ped, &width ) ) {
            if( IsValid( roc, nx, ch ) ) {
                fPedestals[roc][nx][ch] = ped;
                fWidths[roc][nx][ch] = width;
            }
            else {
                PrintLog( Form("In TPedestalExtractor::LoadFromFile: error when reading pedestals file: roc/nx/ch combination of %d/%d/%d is not valid. Stop reading pedestals", roc, nx, ch) );
                return;
            }
        }
        fclose( pedFile );
    } else {
        printf( "Warning in TPedestalExtractor::LoadFromFile: Reading pedestals in backward-compatibility mode\n" );
        FILE * pedFile = fopen( fileName, "r" );
        if( ! pedFile ) {
            PrintLog( Form("Pedestal file %s not found", fileName) );
            return;
        }
        Int_t iRoc = 0, iNx = 0, iCh = 0;
        float ped;
        while( 1 == fscanf( pedFile, "%f", &ped ) ) {
            if( iRoc < fRocArrSize - 1 || iNx < fNxArrSize - 1 || iCh < fNChannels - 1 ) {
                fPedestals[iRoc][iNx][iCh] = static_cast<Float_t>( ped );
                if( iCh < fNChannels - 1 ) {
                    iCh++;
                }
                else if( iNx < fNxArrSize - 1) {
                    iNx++;
                    iCh = 0;
                }
                else if( iRoc < fRocArrSize -1 ) {
                    iRoc++;
                    iNx = 0;
                    iCh = 0;
                }
            }
            else {
                printf( "Error in TPedestalExtractor::LoadFromFile: Too many lines in the pedestal file\n" );
                break;
            }
        }
        if( iRoc != fRocArrSize - 1 || iNx != fNxArrSize - 1 || iCh != fNChannels - 1 ) {
            printf( "Error in TPedestalExtractor::LoadFromFile: The pedestal file is expected to contain more lines\n" );
        }
        fclose( pedFile );
    }
}



/*
 * Print pedestals and widths in all channels of all n-XYTERs on all ROCs.
 */
void TPedestalExtractor::Print() const
{
        for(Int_t iRoc = 0; iRoc < fRocArrSize; iRoc++) {
                Print( iRoc );
        }
}


/*
 * Print pedestals and widths in all channels of all n-XYTERs on the particular ROC.
 */
void TPedestalExtractor::Print( Int_t roc ) const
{
        if( IsRocValid( roc ) ) {
                for(Int_t iNx = 0; iNx < fNxArrSize; iNx++) {
                        for(Int_t iChannel = 0; iChannel < fNChannels; iChannel++) {
                                printf( "roc=%2d   nx=%2d   ch=%3d   ped=%7.1f   nEnt=%10.1f\n", roc, iNx, iChannel, fPedestals[roc][iNx][iChannel], fBaselines[roc][iNx][iChannel]->GetEntries());
                        }
                }
        }
}



void TPedestalExtractor::SaveToFile( Char_t const * fileName) const
{
    PrintLog( Form( "Storing pedestals into file %s", fileName), 1 );

    std::ofstream pedestalfile;
    pedestalfile.open(fileName);

    for( Int_t iRoc = 0; iRoc < GetRocArrSize(); iRoc++ ) {
        for( Int_t iNx = 0; iNx < GetNxArrSize(); iNx++ ) {
            for( Int_t iCh = 0; iCh < GetNChannels(); iCh++ ) {
                pedestalfile << Form("%4d%4d%6d%10.2f%10.2f\n", iRoc, iNx, iCh, GetPedestal(iRoc, iNx, iCh), GetWidth(iRoc, iNx, iCh) );
            }
        }
    }
    pedestalfile.close();
}



roc::SysMessageUserTypes TPedestalExtractor::GetState( Int_t roc ) const
{
        if( IsRocValid( roc ) ) {
                return fState[roc];
        }
        printf("ERROR in TPedestalExtractor::GetState: invalid roc numben");
        return roc::SYSMSG_USER_RECONFIGURE;
}