TemplateWriter.cxx

Go to the documentation of this file.

#include "TemplateWriter.h"

#include "TemplateCalculator.h"

#include <iostream>
#include <cmath>
#include <cassert>

using namespace OscFit;

ClassImp(TemplateWriter)

static TemplateWriter* fgTemplateWriter = 0;

TemplateWriter* TemplateWriter::Instance()
{
  if( !fgTemplateWriter ){
    fgTemplateWriter = new TemplateWriter();
  }

  return fgTemplateWriter;
}

TemplateWriter::TemplateWriter()
{
  std::cout << " *** TemplateWriter::TemplateWriter() *** " << std::endl;

  fTemplateArray = new TemplateArray();

  fTemplateDummy = new Template();
  fTemplateDummy->BuildHistograms();

  fTemplateFHC = new Template();
  fTemplateFHC->BuildHistograms();

  fTemplateRHC = new Template();
  fTemplateRHC->BuildHistograms();

  fTemplateALL = new Template();
  fTemplateALL->BuildHistograms();

  fDirHandle = 0;
  fFileHandle = 0;
}

TemplateWriter::~TemplateWriter()
{
  delete fTemplateArray;
  delete fTemplateDummy;

  delete fTemplateFHC;
  delete fTemplateRHC;
  delete fTemplateALL;
}
 
void TemplateWriter::WriteSystematics( const char* filename )
{
  std::cout << " *** TemplateWriter::WriteSystematics(...) *** " << std::endl;

  TString name = filename;
  TString tag = "";

  // No Oscillations
  name = filename;
  tag = ".noosc";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( name );

  // Normalisation
  name = filename;
  tag = ".noosc.sys.norm.m1";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( 0.0, 0.0, 0.0, 0.0,
                    -1.0, 0.0, 0.0, 0.0, name);

  name = filename;
  tag = ".noosc.sys.norm.p1";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( 0.0, 0.0, 0.0, 0.0,
                    +1.0, 0.0, 0.0, 0.0, name); 

  // NC Background
  name = filename;
  tag = ".noosc.sys.ncbkg.m1";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( 0.0, 0.0, 0.0, 0.0,
                     0.0,-1.0, 0.0, 0.0, name);

  name = filename;
  tag = ".noosc.sys.ncbkg.p1";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( 0.0, 0.0, 0.0, 0.0,
                     0.0,+1.0, 0.0, 0.0, name);  

  // Shower Energy
  name = filename;
  tag = ".noosc.sys.shwen.m1";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( 0.0, 0.0, 0.0, 0.0,
                     0.0, 0.0,-1.0, 0.0, name);

  name = filename;
  tag = ".noosc.sys.shwen.p1";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( 0.0, 0.0, 0.0, 0.0,
                     0.0, 0.0,+1.0, 0.0, name);  

  // Track Energy
  name = filename;
  tag = ".noosc.sys.trken.m1";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( 0.0, 0.0, 0.0, 0.0,
                     0.0, 0.0, 0.0,-1.0, name);

  name = filename;
  tag = ".noosc.sys.trken.p1";

  if( name.EndsWith(".root") ) 
    name.Insert(name.Length()-5,tag);
  else name.Append(tag);

  this->WriteToFile( 0.0, 0.0, 0.0, 0.0,
                     0.0, 0.0, 0.0,+1.0, name);


  // Other systematics go here
  if( OscFit::GetNumSystematics()>3 ){ // NCBkg, ShwEn, TrkEn
    std::cout << " <warning> not accounting for all systematics - abort! " << std::endl;
    assert(0);
  }

  return;
}
 
void TemplateWriter::WriteExpectation( const char* filename )
{
  return this->WriteToFile( filename );
}

void TemplateWriter::WriteExpectation( Double_t dmsq, Double_t sinsq, const char* filename )
{
  return this->WriteToFile( dmsq, sinsq, dmsq, sinsq, filename );
}

void TemplateWriter::WriteExpectation( Double_t dmsq, Double_t sinsq, Double_t dmsqbar, Double_t sinsqbar, const char* filename )
{
  return this->WriteToFile( dmsq, sinsq, dmsqbar, sinsqbar, filename );
}

void TemplateWriter::WriteExpectation( Double_t dmsq, Double_t sinsq, Double_t dmsqbar, Double_t sinsqbar, Double_t norm, Double_t ncbkg, Double_t shwen, Double_t trken, const char* filename )
{
  return this->WriteToFile( dmsq, sinsq, dmsqbar, sinsqbar,
                            norm, ncbkg, shwen, trken,
                            filename );
}

void TemplateWriter::WriteToFile( const char* filename )
{
  return this->WriteToFile( 0.0, 0.0, filename );
}

void TemplateWriter::WriteToFile( Double_t dmsq, Double_t sinsq, const char* filename )
{
  return this->WriteToFile( dmsq, sinsq, dmsq, sinsq, filename );
}

void TemplateWriter::WriteToFile( Double_t dmsq, Double_t sinsq, Double_t dmsqbar, Double_t sinsqbar, const char* filename )
{
  return this->WriteToFile( dmsq, sinsq, dmsqbar, sinsqbar,
                            0.0, 0.0, 0.0, 0.0, filename );
}

void TemplateWriter::WriteToFile( Double_t dmsq, Double_t sinsq, Double_t dmsqbar, Double_t sinsqbar, Double_t norm, Double_t ncbkg, Double_t shwen, Double_t trken, const char* filename )
{
  std::cout << " *** TemplateWriter::WriteToFile(...) *** " << std::endl;

  std::cout << "  dmsq=" << dmsq << " sinsq=" << sinsq << std::endl
            << "  dmsqbar=" << dmsqbar << " sinsqbar=" << sinsqbar << std::endl
            << "  norm=" << norm << " ncbkg=" << ncbkg << std::endl
            << "  shwen=" << shwen << " trken=" << trken << std::endl;

  this->OpenFile( filename );

  // GetExpectation(...)
  // -------------------
  // Arguments: cv, cvtau, rock, rocktau,
  //            ccnu, ccnubar, nc, 

  // ALL
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  1,1,1,1,
                                                  1,1,1,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kData, OscFit::kNull, fTemplateArray );

  // CV, ALL
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  1,1,0,0,
                                                  1,1,1,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kCV, OscFit::kNull, fTemplateArray );

  // CV, NU CC 
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  1,1,0,0,
                                                  1,0,0,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kCV, OscFit::kCCnu, fTemplateArray );

  // CV, NUBAR CC
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  1,1,0,0,
                                                  0,1,0,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kCV, OscFit::kCCnubar, fTemplateArray );
 
  // CV, NC
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  1,0,0,0,
                                                  0,0,1,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kCV, OscFit::kNC, fTemplateArray );

  // CV, TAU
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  0,1,0,0,
                                                  1,1,0,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kCVTau, OscFit::kNull, fTemplateArray );

  // ROCK, ALL
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  0,0,1,1,
                                                  1,1,1,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kRock, OscFit::kNull, fTemplateArray );

  // ROCK, NU CC 
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  0,0,1,1,
                                                  1,0,0,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kRock, OscFit::kCCnu, fTemplateArray );

  // ROCK, NUBAR CC
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  0,0,1,1,
                                                  0,1,0,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kRock, OscFit::kCCnubar, fTemplateArray );

  // ROCK, NC
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  0,0,1,0,
                                                  0,0,1,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kRock, OscFit::kNC, fTemplateArray );

  // ROCK, TAU
  TemplateCalculator::Instance()->GetExpectation( dmsq, sinsq,
                                                  dmsqbar, sinsqbar,
                                                  0,0,0,1,
                                                  1,1,0,
                                                  norm, ncbkg,
                                                  shwen, trken,
                                                  fTemplateArray );
  this->AddToFile( OscFit::kRockTau, OscFit::kNull, fTemplateArray );


  this->CloseFile();
}

void TemplateWriter::WriteData( const char* filename )
{
  TemplateCalculator::Instance()->GetData( fTemplateArray );

  return this->WriteToFile( fTemplateArray, filename );
}

void TemplateWriter::WriteToFile( TemplateArray* tempArray, const char* filename )
{
  if( tempArray==0 ) return;

  std::cout << " *** TemplateWriter::WriteToFile(...) *** " << std::endl;

  this->OpenFile( filename );

  this->AddToFile( OscFit::kData, OscFit::kNull, tempArray );

  this->CloseFile();
}

void TemplateWriter::OpenFile( const char* filename )
{
  std::cout << "  Opening File: " << filename << std::endl;

  if( fFileHandle ) return;

  fDirHandle = gDirectory;
  fFileHandle  = new TFile(filename,"recreate");

  return;
}

void TemplateWriter::CloseFile()
{
  if( fFileHandle==0 ) return;

  std::cout << "  Closing File: " << fFileHandle->GetName() << std::endl;

  fFileHandle->Close();
  fFileHandle = 0;
  gDirectory = fDirHandle;
}

void TemplateWriter::AddToFile( Sample_t sample, Interaction_t interaction, TemplateArray* tempArray )
{
  if( tempArray==0 ) return;

  std::cout << "   Writing Templates: [" << AsString(sample) << "]";
  if( interaction != OscFit::kNull) std::cout << "[" << AsString(interaction) << "]"; 
  std::cout << std::endl;
    
  // Base name for histograms
  TString baseName = "h"; 
  TString tempName = "";
  if( sample != OscFit::kData ){
    baseName.Append("_"); baseName.Append( OscFit::AsString(sample) );
  }
  if( interaction != OscFit::kNull ){
    baseName.Append("_"); baseName.Append( OscFit::AsString(interaction) );
  }

  // Reset Summed Histograms
  fTemplateFHC->Reset();
  fTemplateRHC->Reset();
  fTemplateALL->Reset();

  // Loop over runs
  for( Int_t irun=0; irun<OscFit::GetNumRuns(); irun++ ){
    Run_t run = OscFit::GetRun(irun);
    Template* temp = tempArray->GetTemplate(run);
    if( temp==0 ) temp = fTemplateDummy;

    tempName = baseName; tempName.Append("_"); 
    tempName.Append( OscFit::AsString(run) );

    this->AddToFile( temp, tempName.Data() );

    if( OscFit::GetRunType(run)==OscFit::kFHC ) fTemplateFHC->Add( temp );
    if( OscFit::GetRunType(run)==OscFit::kRHC ) fTemplateRHC->Add( temp );
    fTemplateALL->Add( temp );
  }

  // Write out Summed Histograms
  tempName = baseName; tempName.Append("_"); 
  tempName.Append( OscFit::AsString(OscFit::kFHC) );
  this->AddToFile( fTemplateFHC, tempName.Data() );  

  tempName = baseName; tempName.Append("_"); 
  tempName.Append( OscFit::AsString(OscFit::kRHC) );
  this->AddToFile( fTemplateRHC, tempName.Data() );

  tempName = baseName; tempName.Append("_all"); 
  this->AddToFile( fTemplateALL, tempName.Data() );

  return;
}    

void TemplateWriter::AddToFile( Template* temp, const char* baseName )
{
  if( temp==0 ) return;

  // Names of Summed Histograms
  TString histNameFiducial = baseName; 
  histNameFiducial.Append("_fiducial"); 
  TH1D* hFiducial = 0;

  TString histNameCorrectSign = baseName; 
  histNameCorrectSign.Append("_correctsign"); 
  TH1D* hCorrectSign = 0;

  // Loop over Histograms
  for( Int_t ibin=0; ibin<OscFit::GetNumBins(); ibin++ ){
    Bin_t bintype = OscFit::GetBin(ibin);
      
    // Get Histograms
    TString histName = baseName; histName.Append("_"); 
    histName.Append( OscFit::AsString(bintype) );

    Histogram* hist = temp->GetHistogramByType(bintype);
    TH1D* h = hist->MakeTH1D( histName.Data() );
 
    // Add to Sum: Fiducial Events (All)
    if( ibin>=OscFit::GetFirstFiducialBin()
     && ibin<=OscFit::GetLastFiducialBin() ){
      if( hFiducial==0 ){
        hFiducial = (TH1D*)(h->Clone(histNameFiducial.Data()));
      }
      else{
        hFiducial->Add( h );
      }
    }

    // Add to Sum: Fiducial Events (Correct Sign)
    if( ibin>=OscFit::GetFirstCorrectSignBin()
     && ibin<=OscFit::GetLastCorrectSignBin() ){
      if( hCorrectSign==0 ){
        hCorrectSign = (TH1D*)(h->Clone(histNameCorrectSign.Data()));
      }
      else{
        hCorrectSign->Add( h );
      }
    }

    // Write Histogram
    h->Write();
  }

  // Write out Summed Histograms
  hFiducial->Write();
  hCorrectSign->Write();

  return;
}  

---