MJVWaveform.cc

Go to the documentation of this file.

//---------------------------------------------------------------------------//
//bb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nu//
//                                                                           //
//                         MAJORANA Simulation                               //
//                                                                           //
//      This code implementation is the intellectual property of the         //
//      MAJORANA Collaboration. It is based on Geant4, an intellectual       //
//      property of the RD44 GEANT4 collaboration.                           //
//                                                                           //
//                        *********************                              //
//                                                                           //
//    Neither the authors of this software system, nor their employing       //
//    institutes, nor the agencies providing financial support for this      //
//    work  make  any representation or  warranty, express or implied,       //
//    regarding this software system or assume any liability for its use.    //
//    By copying, distributing or modifying the Program (or any work based   //
//    on on the Program) you indicate your acceptance of this statement,     //
//    and all its terms.                                                     //
//                                                                           //
//bb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nu//
//---------------------------------------------------------------------------//
//                                                          
// $Id: MJVWaveform.cc,v 1.2 2004/11/09 13:42:39 xliu Exp $ 
//      
// CLASS IMPLEMENTATION:  MJVWaveform.cc
//
//---------------------------------------------------------------------------//
// 
//---------------------------------------------------------------------------//
//---------------------------------------------------------------------------//
//

#include "io/MJLogger.hh"

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

#include "waveform/MJVWaveform.hh"      //Present MJ Class Headers 

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

MJVWaveform::MJVWaveform():
  fChargeAllocated(false), fCurrentAllocated(false),fDigitizedAllocated(false),
  fChargeSignal(0), fCurrentSignal(0), fDigitizedSignal(0)
{;}

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

MJVWaveform::MJVWaveform(const MJVWaveform & other)
{;}

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

MJVWaveform::~MJVWaveform()
{
  if(fChargeAllocated) delete [] fChargeSignal;
  if(fCurrentAllocated) delete [] fCurrentSignal;
  if(fDigitizedAllocated) delete [] fDigitizedSignal;  
}

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

void MJVWaveform::AddChargePoint(HepDouble charge)
{
  if(fChargeAllocated && !fChargeArrayFull){
    if(fChargeStep < fNumberOfChargePoints && !fChargeArrayFull) {
      fChargeSignal[fChargeStep] = charge;
      fChargeTime = fChargeStep++ * fChargeTimeStep;
    } else {
      fChargeArrayFull = true;
      MJLog(trace) << "MJVWaveform::AddChargePoint : fChargeSignal array full "
                   << fChargeStep << " " << fNumberOfChargePoints << '\n';
    }
  } else {
    MJLog(error) << "MJWaveform::AddChargePoint : Charge array not allocated."
                 << " or full.\n";
  }    
}

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

void MJVWaveform::AddCurrentPoint(HepDouble current)
{
  if(fCurrentAllocated && !fCurrentArrayFull){
    if(fCurrentStep < fNumberOfCurrentPoints) {
      fCurrentSignal[fCurrentStep] = current;
      fCurrentTime = fCurrentStep++ * fCurrentTimeStep;
    } else {
      fCurrentArrayFull = true;
      MJLog(trace)<<"MJVWaveform::AddCurrentPoint : fCurrentSignal array full "
                  << fCurrentStep << " " << fNumberOfCurrentPoints << "\n";
    }
  } else {
    MJLog(error)<<"MJWaveform::AddCurrentPoint : Current array not allocated"
                << " or full.\n";
  }    
}

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

void MJVWaveform::AddDigitizedPoint(HepInt signal)
{
  if(fDigitizedAllocated && !fDigitizedArrayFull){
    if(fDigitizedStep < fNumberOfDigitizedPoints) {
      fDigitizedSignal[fDigitizedStep] = signal;
      fDigitizedTime = fDigitizedStep++ * fDigitizedTimeStep;
    } else {
      fDigitizedArrayFull = false;
      MJLog(trace)<<"MJVWaveform::AddDigitizedPoint : fDigitizedSignal array"
                  << "full " << fDigitizedStep << " " 
                  << fNumberOfDigitizedPoints  << '\n';
    }
  } else {
    MJLog(error) << "MJWaveform::AddDigitizedPoint : Digitized array not "
                 << "allocated or full.\n";
  }    
}

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

void MJVWaveform::AllocateChargeSignal()
{
  if(fNumberOfChargePoints > 0) {
    if(!(fChargeSignal = new HepDouble[fNumberOfChargePoints])){ 
      MJLog(error) << "MJVWaveform::AllocateChargeSignal(): Array allocation"
                   << " returned NULL pointer." << "\n"; 
      MJLog(fatal);
    }
  } else {
    MJLog(error) << "MJVWaveform::AllocateChargeSignal(): Cannot allocate "
                 << "array of size < 1 : " << fNumberOfChargePoints << "\n";
    MJLog(fatal);
  }
  fChargeAllocated = true;
  fChargeArrayFull = false;
  fChargeStep = 0;
  fChargeTime = 0.0;
  MJLog(trace) << "MJVWaveform::AllocateChargeSignal(): Allocate array of" <<
    " length : " << fNumberOfChargePoints << '\n';
}

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

void MJVWaveform::AllocateCurrentSignal()
{
  if(fNumberOfCurrentPoints > 0) {
    if(!(fCurrentSignal = new HepDouble[fNumberOfCurrentPoints])){ 
      MJLog(error) << "MJVWaveform::AllocateCurrentSignal(): Array allocation"
                   << " returned NULL pointer." << "\n"; 
      MJLog(fatal);
    }
  } else {
    MJLog(error) << "MJVWaveform::AllocateCurrentSignal(): Cannot allocate" <<
      "array of size < 1 : " << fNumberOfCurrentPoints << "\n";
    MJLog(fatal);
  }
  fCurrentAllocated = true;
  fCurrentArrayFull = false;
  fCurrentStep = 0;
  fCurrentTime = 0.0;
  MJLog(trace) << "MJVWaveform::AllocateCurrentSignal(): Allocate array of" <<
    " length : " << fNumberOfCurrentPoints << '\n';
}


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

void MJVWaveform::AllocateDigitizedSignal()
{
  if(fNumberOfDigitizedPoints > 0) {
    if(!(fDigitizedSignal = new HepInt[fNumberOfDigitizedPoints])){ 
      MJLog(error) << "MJVWaveform::AllocateDigitizedSignal(): Array"
                   << " allocation returned NULL pointer." << "\n"; 
      MJLog(fatal);
    }
  } else {
    MJLog(error) << "MJVWaveform::AllocateDigitizedSignal(): Cannot allocate"<<
      "array of size < 1 : " << fNumberOfDigitizedPoints << "\n";
    MJLog(fatal);
  }
  fDigitizedAllocated = true;
  fDigitizedArrayFull = false;
  fDigitizedStep = 0;
  fDigitizedTime = 0.0;
  MJLog(trace) << "MJVWaveform::AllocateDigitizedSignal(): Allocated array"<<
    " of length : " << fNumberOfDigitizedPoints << 'n';
}

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

void MJVWaveform::AllocateChargeSignal(HepInt numberofpoints)
{
  fNumberOfChargePoints = numberofpoints;
  AllocateChargeSignal();
}

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

void MJVWaveform::AllocateCurrentSignal(HepInt numberofpoints)
{
  fNumberOfCurrentPoints = numberofpoints;
  AllocateCurrentSignal();
}

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

void MJVWaveform::AllocateDigitizedSignal(HepInt numberofpoints)
{
  fNumberOfDigitizedPoints = numberofpoints;
  AllocateDigitizedSignal();
}

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

void MJVWaveform::IntegrateChargePoint(HepDouble charge)
{
  if(fChargeAllocated && !fChargeArrayFull){
    if(fChargeStep < fNumberOfChargePoints && !fChargeArrayFull) {
      fChargeSignal[fChargeStep] = fChargeStep ? 
        charge + fChargeSignal[fChargeStep - 1] : charge;
      fChargeTime = fChargeStep++ * fChargeTimeStep;
    } else {
      fChargeArrayFull = true;
      MJLog(trace) << "MJVWaveform::AddChargePoint : fChargeSignal array full "
                   << fChargeStep << " " << fNumberOfChargePoints << '\n';
    }
  } else {
    MJLog(error) << "MJWaveform::AddChargePoint : Charge array not allocated."
                 << " or full.\n";
  }    
}

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

void MJVWaveform::SetAllZero()
{
  HepInt i;

  if(fChargeAllocated) 
    for(i = 0; i < fNumberOfChargePoints; i++)
      fChargeSignal[i] = 0.0;
  if(fCurrentAllocated) 
    for(i = 0; i < fNumberOfCurrentPoints; i++)
      fCurrentSignal[i] = 0.0;
  if(fDigitizedAllocated) 
    for(i = 0; i < fNumberOfDigitizedPoints; i++)
      fDigitizedSignal[i] = 0;
  fChargeStep = fCurrentStep = fDigitizedStep = 0; 
  fChargeTime = fCurrentTime = fDigitizedTime = 0.0;
}

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

---