NtpSRRecord.cxx

Go to the documentation of this file.

// 
// NtpSRRecord
//
// NtpSRRecord is an ntuple record serving the SR reconstruction path
//

#include <iostream>
using namespace std;

#include "TClonesArray.h"
#include "Record/RecArrayAllocator.h"
#include "CandNtupleSR/NtpSRRecord.h"
#include "CandNtupleSR/NtpSRSlice.h"
#include "CandNtupleSR/NtpSRCluster.h"
#include "CandNtupleSR/NtpSRShower.h"
#include "CandNtupleSR/NtpSRTrack.h"
#include "CandNtupleSR/NtpSREvent.h"
#include "CandNtupleSR/NtpSRDeadChip.h"
#include "MessageService/MsgService.h"

CVSID("$Id: NtpSRRecord.cxx,v 1.14 2006/06/30 22:01:19 blake Exp $");

ClassImp(NtpSRRecord)

  NtpSRRecord::NtpSRRecord() : RecRecordImp<RecCandHeader>(),deadchips(0),vetostp(0),vetoexp(0),stp(0),
  slc(0),clu(0),shw(0),trk(0),evt(0) {
  // Purpose: Default constructor

  MSG("NtpSR",Msg::kVerbose) << "NtpSRRecord def ctor at " << this << endl;
  this -> Init();  
}

NtpSRRecord::NtpSRRecord(const RecCandHeader& hdr) : 
  RecRecordImp<RecCandHeader>(hdr),deadchips(0),vetostp(0),vetoexp(0),stp(0),slc(0),clu(0),shw(0),trk(0),
     evt(0) {
  // Purpose: Normal constructor

  MSG("NtpSR",Msg::kVerbose) << "NtpSRRecord normal ctor at " << this << endl;
  this -> Init(); 
}

NtpSRRecord::~NtpSRRecord() {
  // Purpose: Destructor

  MSG("NtpSR",Msg::kVerbose) << "NtpSRRecord dtor at " << this << endl;
  // Release arrays back to TClonesArray pool for reuse
  // Allocated memory of stored objects is retrieved via object Clear call
  RecArrayAllocator& allocator = RecArrayAllocator::Instance();
  if ( deadchips ){ allocator.ReleaseArray(deadchips); deadchips = 0; }
  if ( vetostp ) { allocator.ReleaseArray(vetostp); vetostp = 0; }
  if ( vetoexp ) { allocator.ReleaseArray(vetoexp); vetoexp = 0; }
  if ( stp ) { allocator.ReleaseArray(stp); stp = 0; }
  if ( slc ) { allocator.ReleaseArray(slc); slc = 0; }
  if ( clu ) { allocator.ReleaseArray(clu); clu = 0; }
  if ( shw ) { allocator.ReleaseArray(shw); shw = 0; }
  if ( trk ) { allocator.ReleaseArray(trk); trk = 0; }
  if ( evt ) { allocator.ReleaseArray(evt); evt = 0; }
   
}

void NtpSRRecord::Clear(Option_t* /* option */) {
  // Purpose: Clear memory allocated to arrays so that record can
  // be reused.  

  if ( deadchips ) { deadchips->Clear("C"); }
  if ( vetostp ) { vetostp -> Clear("C"); }
  if ( vetoexp ) { vetoexp -> Clear("C"); }
  if ( stp ) { stp -> Clear("C"); }
  if ( slc ) { slc -> Clear("C"); }
  if ( clu ) { clu -> Clear("C"); }
  if ( shw ) { shw -> Clear("C"); }
  if ( trk ) { trk -> Clear("C"); }
  if ( evt ) { evt -> Clear("C"); }
   
}

void NtpSRRecord::ClearStrips(Option_t* /* option */) {
  // Purpose: Clear strip data from record to reduce size

  if ( vetostp ) { vetostp -> Clear("C"); } // clear array and contents
  if ( vetoexp ) { vetoexp -> Clear("C"); } // clear array and contents  
  if ( stp ) { stp -> Clear("C"); } // clear array and contents

  if ( slc ) {
    TClonesArray& slicearray = *(slc);
    for ( int islc = 0; islc <= slicearray.GetLast(); islc++ ) {
      NtpSRSlice* ntpslice = dynamic_cast<NtpSRSlice*>(slicearray.At(islc));
      ntpslice -> ClearStrips();
    }
  }

  if( clu ) {
    TClonesArray& clusterarray = *(clu);
    for ( int iclu = 0; iclu <= clusterarray.GetLast(); iclu++ ) {
      NtpSRCluster* ntpcluster = 
        dynamic_cast<NtpSRCluster*>(clusterarray.At(iclu));
      ntpcluster->ClearStrips();
    }
  }

  if ( shw ) {
    TClonesArray& showerarray = *(shw);
    for ( int ishw = 0; ishw <= showerarray.GetLast(); ishw++ ) {
      NtpSRShower* ntpshower=dynamic_cast<NtpSRShower*>(showerarray.At(ishw));
      ntpshower -> ClearStrips();
    }
  }

  if ( trk ) {
    TClonesArray& trackarray = *(trk);
    for ( int itrk = 0; itrk <= trackarray.GetLast(); itrk++ ) {
      NtpSRTrack* ntptrack=dynamic_cast<NtpSRTrack*>(trackarray.At(itrk));
      ntptrack -> ClearStrips();
    }
  }

  if ( evt ) {
    TClonesArray& eventarray = *(evt);
    for ( int ievt = 0; ievt <= eventarray.GetLast(); ievt++ ) {
      NtpSREvent* ntpevent=dynamic_cast<NtpSREvent*>(eventarray.At(ievt));
      ntpevent -> ClearStrips();
    }
  }
}

void NtpSRRecord::Init() {
  // 
  // Purpose: Initialize ntuple TClonesArrays
  //

  // Set variable in record base class to indicate that it is possible
  // to recover dynamic memory using Clear() method for this record type
  SetClearable(true);
  
  RecArrayAllocator& allocator = RecArrayAllocator::Instance();
  if ( !deadchips ) deadchips = allocator.GetArray("NtpSRDeadChip");
  if ( !vetostp ) vetostp = allocator.GetArray("NtpSRShieldStrip");
  if ( !vetoexp ) vetoexp = allocator.GetArray("NtpSRShieldExpected");
  if ( !stp ) stp = allocator.GetArray("NtpSRStrip");
  if ( !slc ) slc = allocator.GetArray("NtpSRSlice");
  if ( !clu ) clu = allocator.GetArray("NtpSRCluster");
  if ( !shw ) shw = allocator.GetArray("NtpSRShower");
  if ( !trk ) trk = allocator.GetArray("NtpSRTrack");
  if ( !evt ) evt = allocator.GetArray("NtpSREvent");

 }

std::ostream& NtpSRRecord::Print(std::ostream& os) const {
  //
  // Purpose: Print status of ntuple record on ostream
  //

  os << "NtpSRRecord::Print" << endl;
  RecRecordImp<RecCandHeader>::Print(os);

  evthdr.Print(os);
  
  if ( slc ) {
    TClonesArray& slicearray = *(slc);
    for ( int islc = 0; islc <= slicearray.GetLast(); islc++ ) {
      NtpSRSlice* ntpslice = dynamic_cast<NtpSRSlice*>(slicearray.At(islc));
      ntpslice -> Print(os);
    }
  }

  if ( shw ) {
    TClonesArray& showerarray = *(shw);
    for ( int ishw = 0; ishw <= showerarray.GetLast(); ishw++ ) {
      NtpSRShower* ntpshower=dynamic_cast<NtpSRShower*>(showerarray.At(ishw));
      ntpshower -> Print(os);
    }
  }

  if ( trk ) {
    TClonesArray& trackarray = *(trk);
    for ( int itrk = 0; itrk <= trackarray.GetLast(); itrk++ ) {
      NtpSRTrack* ntptrack=dynamic_cast<NtpSRTrack*>(trackarray.At(itrk));
      ntptrack -> Print(os);
    }
  }

  if ( evt ) {
    TClonesArray& eventarray = *(evt);
    for ( int ievt = 0; ievt <= eventarray.GetLast(); ievt++ ) {
      NtpSREvent* ntpevent=dynamic_cast<NtpSREvent*>(eventarray.At(ievt));
      ntpevent -> Print(os);
    }
  }
  
  return os;

}

void NtpSRRecord::Print(Option_t* /* option */) const {
  //
  // Purpose: Print record in form supported by TObject::Print
  //

  Print(std::cout);
  return;

}

---