/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Emc/EmcCalib/EmcBhaCalib/EmcBhaCalib-00-00-34/src/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 "EmcBhaCalib/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;
  }
}

---