EmcBhaCalibData.cxx

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//
//
// Description:
//      Class EmcBhaCalibData - see header
//
// Environment:
//      Software developed for the BESIII Detector at the BEPCII.
//
// Author List:
//      Chunxiu Liu
//
// Copyright Information:
//      Copyright (C) 2005           IHEP
//
//------------------------------------------------------------------------
 
//-----------------------
// This Class's Header --
//-----------------------
#include "EmcBhaCalibData.h"
 
//-------------
// C Headers --
//-------------
extern "C" {}
 
//---------------
// C++ Headers --
//---------------
 
#include <cstring>
 
using namespace std;
//-------------------------------
// Collaborating Class Headers --
//-------------------------------
 
//              ----------------------------------------
//              -- Public Function Member Definitions --
//              ----------------------------------------
 
//----------------
// Constructors --
//----------------
EmcBhaCalibData::EmcBhaCalibData( int numxtals ) : _nXtals( numxtals ), _nXtalsHit( 0 ) {
  //  _matrixM = new EmcLSSMatrix(_nXtals,600);
  _matrixM     = new EmcLSSMatrix( _nXtals, _nXtals );
  _vectorR     = new double[_nXtals];
  _xtalInd     = new int[_nXtals];
  _xtalHits    = new int[_nXtals];
  _xtalHitsMax = new int[_nXtals];
  for ( int i = 0; i < _nXtals; i++ )
  {
    _vectorR[i]     = 0.;
    _xtalInd[i]     = i;
    _xtalHits[i]    = 0;
    _xtalHitsMax[i] = 0;
  }
  _MsgFlag = 0;
}
 
//----------------
// Constructors --
//----------------
EmcBhaCalibData::EmcBhaCalibData( int numxtals, int MsgFlag )
    : _nXtals( numxtals ), _nXtalsHit( 0 ) {
  //  _matrixM = new EmcLSSMatrix(_nXtals,600);
  _matrixM     = new EmcLSSMatrix( _nXtals, _nXtals, MsgFlag );
  _vectorR     = new double[_nXtals];
  _xtalInd     = new int[_nXtals];
  _xtalHits    = new int[_nXtals];
  _xtalHitsMax = new int[_nXtals];
  for ( int i = 0; i < _nXtals; i++ )
  {
    _vectorR[i]     = 0.;
    _xtalInd[i]     = i;
    _xtalHits[i]    = 0;
    _xtalHitsMax[i] = 0;
  }
 
  _MsgFlag = MsgFlag;
}
 
//--------------
// Destructor --
//--------------
EmcBhaCalibData::~EmcBhaCalibData() {
  if ( 0 != _matrixM )
  {
    delete _matrixM;
    _matrixM = 0;
  }
  if ( 0 != _vectorR )
  {
    delete[] _vectorR;
    _vectorR = 0;
  }
  if ( 0 != _xtalInd )
  {
    delete[] _xtalInd;
    _xtalInd = 0;
  }
  if ( 0 != _xtalHits )
  {
    delete[] _xtalHits;
    _xtalHits = 0;
  }
  if ( 0 != _xtalHitsMax )
  {
    delete[] _xtalHitsMax;
    _xtalHitsMax = 0;
  }
}
//-------------
// Operators --
//-------------
 
//-------------
// Selectors --
//-------------
 
//-------------
// Modifiers --
//-------------
 
void EmcBhaCalibData::writeOut( ostream& OutM, ostream& OutV ) {
 
  // write only non zero elements to file
  OutM.setf( ios::scientific, ios::floatfield );
  OutV.setf( ios::scientific, ios::floatfield );
  OutV.precision( 12 );
  OutM.precision( 12 );
 
  _matrixM->writeOut( OutM );
 
  _nXtalsHit = 0;
 
  double* vect_ele = _vectorR;
  double* vect_end = _vectorR + _nXtals;
  int*    xtal_ind = _xtalInd;
  int*    hits_max = _xtalHitsMax;
  int*    hits     = _xtalHits;
 
  while ( vect_ele < vect_end )
  {
    if ( *vect_ele != 0. ) { _nXtalsHit++; }
    vect_ele++;
  }
 
  OutV << _nXtalsHit << " ";
 
  vect_ele = _vectorR;
 
  while ( vect_ele < vect_end )
  {
    if ( *vect_ele != 0. )
    { OutV << *xtal_ind << " " << *hits << " " << *hits_max << " " << *vect_ele << " "; }
    xtal_ind++;
    vect_ele++;
    hits_max++;
    hits++;
  }
}
 
void EmcBhaCalibData::readIn( istream& InM, istream& InV ) {
 
  _matrixM->readIn( InM );
 
  _matrixM->print_NonZeros();
 
  // cout<<"num_filled_rows(48)="<<_matrixM->num_filled_rows(48)<<endl;
  // cout<<"num_filled_cols(48)="<<_matrixM->num_filled_cols(48)<<endl;
 
  // cout<<"matrix(47,47)"<<_matrixM->operator()(47,47)<<endl;
 
  double vect_ele;
  int    nr_ele;
  int    xtal_ind;
  int    hits;
  int    hits_max;
 
  InV >> nr_ele;
 
  for ( int i = 0; i < nr_ele; i++ )
  {
 
    InV >> xtal_ind >> hits >> hits_max >> vect_ele;
 
    if ( _vectorR[xtal_ind] == 0. ) { _nXtalsHit++; }
 
    _vectorR[xtal_ind] += vect_ele;
    _xtalInd[xtal_ind] = xtal_ind;
    _xtalHits[xtal_ind] += hits;
    _xtalHitsMax[xtal_ind] += hits_max;
  }
}
 
bool EmcBhaCalibData::reduce() {
 
  bool successful = true;
 
  // delete all zero elements in matrix and vector R
  // save only non zero elements (this format is needed by slap),
  // keep the original xtal index in array xtalInd
 
  // array to store the new row/column reference for later matrix reduction
  int* xRef = new int[_nXtals];
  memset( xRef, -1, ( _nXtals * sizeof( int ) ) );
 
  _nXtalsHit = 0;
  for ( int _arrayIndx = 0; _arrayIndx < _nXtals; _arrayIndx++ )
  {
 
    if ( _vectorR[_arrayIndx] > 0. )
    {
 
      _vectorR[_nXtalsHit]     = _vectorR[_arrayIndx];
      _xtalInd[_nXtalsHit]     = _xtalInd[_arrayIndx];
      _xtalHits[_nXtalsHit]    = _xtalHits[_arrayIndx];
      _xtalHitsMax[_nXtalsHit] = _xtalHitsMax[_arrayIndx];
      xRef[_arrayIndx]         = _nXtalsHit;
 
      _nXtalsHit++;
    }
  }
 
  successful = _matrixM->reduce_Matrix( xRef );
 
  delete[] xRef;
 
  return successful;
}
 
void EmcBhaCalibData::reset() {
  _nXtalsHit = 0;
  _matrixM->reset();
 
  for ( int i = 0; i < _nXtals; i++ )
  {
    _vectorR[i]     = 0.;
    _xtalInd[i]     = i;
    _xtalHits[i]    = 0;
    _xtalHitsMax[i] = 0;
  }
}
 
void EmcBhaCalibData::printVec( int number ) {
 
  if ( _MsgFlag <= 3 )
  {
    std::cout << "EmcBhaCalibData:: INFO "
              << "R ( " << number << " ): " << _vectorR[number]
              << "  hits: " << _xtalHits[number] << "  direct hits: " << _xtalHitsMax[number]
              << endl;
  }
}