---

ArchTestResult.cpp

Go to the documentation of this file.

#include "ArchTestResult.h"
#include <TFile.h>
#include <TKey.h>
#include <TDirectory.h>
#include <TSystem.h>
#include <TNamed.h>
#include <TObject.h>
#include <TObjArray.h>
#include <TString.h>
#include <TObjString.h>
#include <TVector.h>
#include <TVectorD.h>
#include <TH1.h>
#include <TH2.h>
#include <TCanvas.h>
#include <TROOT.h>
#include <is/isinfo.h>
#include <iostream>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <iomanip>
#include <fstream>
#include <iostream>
//#include "Sct/shared_ptr_utility.h"

using namespace SctData;
using namespace Sct;
using boost::shared_ptr;



//Global Variables:
//TFile *storage_file = new TFile();



/********************************** ArchScan Methods Definitions ************************/


/***********************  Constructor  *************** */

ArchTestResult::ArchTestResult(): Archiving()  {

  //cout<< "I am in the ArchTestResult Default Constructor"<< endl;
  runNumber = 0;
  moduleName = "0";
  NScans = 0; 
  names = new ArchTestNames();
  //names->SetTestType(testType);
  testSummary = NULL;
}
  
  
ArchTestResult::ArchTestResult(TestResult& test): Archiving()  {

  //cout<< "I am in the ArchTestResult Constructor"<< endl;
  

  /*--- Initialisation ---*/

  
  runNumber = test.getRunNumber();
  moduleName = test.getModuleName();
  testType = test.getClassName();
  NScans = test.getNScans ();

  names = new ArchTestNames(runNumber, moduleName, testType);
  
  

  //Retrieving Raw and Fitted Scans:
  for (unsigned int i=0; i<NScans; i++) {
    unsigned int scanNumber = test.getScanNumberAt(i);
    string RawISName = Archiving::GetRawISUniqueID(runNumber, scanNumber, moduleName);
    rawScans.push_back(ISRetrieveRawScanResult(RawISName));
    
    //Pipeline,FullBypass have no FitScans:
    if (testType != "SctData::PipelineTestResult" && testType != "SctData::FullBypassTestResult" && testType != "SctData::NMaskTestResult") {
      string FitISName = Archiving::GetFitISUniqueID(runNumber, scanNumber, moduleName);
      fitScans.push_back(ISRetrieveFitScanResult(FitISName));
    }
    
    //cout<<" @@@@@@@@@ RAW = " <<RawISName.c_str()<<endl;
    //cout<<" @@@@@@@@@ FIT = " <<FitISName.c_str()<<endl;
    //shared_ptr<RawScanResult> tmp_raw = ISRetrieveRawScanResult(RawISName);
    //shared_ptr<FitScanResult> tmp_fit = ISRetrieveFitScanResult(FitISName);
    //cout<< " NAME = " <<tmp_raw->getUniqueID()<<endl;
    //cout<< " NAME = " <<tmp_fit->getUniqueID()<<endl;

    
  }

  defects = test.getDefects().getAllDefects();
  
  
  testSummary = NULL; //It is filled in each single *TestResult sub-class


}








/**********************  Other Member Functions  *********************/

ArchTestResult::~ArchTestResult()  {
  
  //cout << "I am in the ArchTestResult destructor" << endl;
  

  
}




void ArchTestResult::SaveRawScans()  {
  
  cout << "Saving RawScans " << endl;
  //TO DO : Save time and date of first and last saving

  
  
  for (vector<shared_ptr<const RawScanResult> >::iterator i = rawScans.begin(); i!=rawScans.end(); i++) {
    //shared_ptr<const RawScanResult> raw = *i;   //!!!!! Is there any other better way apart from writing an assignment operator ???????
    const RawScanResult *raw = i->get();
    //const RawScanResult *myraw = shared_ptr_release(raw);
    ArchRawScanResult rscan(*raw);
    rscan.SetTestType(testType);
    rscan.SaveRawScan();
    //delete &raw;
  }
  

  
  
}



void ArchTestResult::SaveFitScans()  {
  
  cout << "Saving FitScans " << endl;
  //TO DO : Save time and date of first and last saving
 
  for (vector<shared_ptr<const FitScanResult> >::iterator i = fitScans.begin(); i!=fitScans.end(); i++) {
    const FitScanResult *fit = i->get(); 
    ArchFitScanResult fscan(*fit);
    fscan.SetTestType(testType);
    fscan.SaveFitScan();
    //delete &fit;
  }
 
  
}




void ArchTestResult::SaveTestDataOnly()  {
  
  cout<<" Saving TestData " << endl;
  
//TO DO : Save time and date of first and last saving  
  
  
  string filename = names->getfilename();
  string moduleID = names->getModuleID();
  string moduleDefectsID = names->getModuleDefectsID();
  string testType  = names->getTestType(); 
  string runID = names->getRunID();
  string DefectsID = names->getDefectsID();


  /* OPENING TEST FILE  */
  cout << "Opening file..."<<endl; 
 

  TFile *storage_file = new TFile(filename.c_str(),"update");
  //storage_file->ls();
  cout << "The file .root succesfully open"<<endl; 

  


  /* CREATING DIRECTORIES and SAVING DATA  */
  
    
    /* Making RunNumber   */
    //cout<<"I am making RunNumber Dir"<<endl;
    //storage_file->GetListOfKeys()->Print();
    TDirectory *this_run = (TDirectory*) gDirectory->Get(runID.c_str());
    //cout<<"The RUN is "<< runID <<endl;
    
    if (!this_run) {
      //cout<<"This NEW run "<< runID <<" doesn't exist"<<endl;
      this_run = storage_file->mkdir(runID.c_str());
      //cout<<"New RunNumber Dir made "<<endl;
    }
    //storage_file->GetListOfKeys()->Print();
    this_run->cd();  //make this_run the current directory
    
   
    /* Saving RunNumber as a TVector: it is saved only once, just the first time   */
    TObject* pers_runnumber = gDirectory->FindObjectAny(runID.c_str()); 
    if (!pers_runnumber) {
      double frunNumber = runNumber;
      TVector run(1,1,frunNumber, "END");
      run.Write(runID.c_str());
    }
    
    
    /* Making moduleNumber   */
    
    TDirectory* this_module = (TDirectory*) gDirectory->Get(moduleID.c_str()); //Can be made using FindAnyObject
    //cout<<"The MODULE is "<< moduleID <<endl;
    if (!this_module) {
      //cout<<"This NEW module "<< moduleID <<" doesn't exist"<<endl;
      this_module =gDirectory ->mkdir(moduleID.c_str());
    }

    /* Making ModuleDefects   */
    TDirectory* this_moduleDefects = (TDirectory*) gDirectory->Get(moduleDefectsID.c_str()); //Can be made using FindAnyObject
    if (!this_moduleDefects) {
      //cout<<"ModuleDefects doesn't exist"<<endl;
      this_moduleDefects =gDirectory ->mkdir(moduleDefectsID.c_str());
    }

    /* Saving ModuleDefects   */
    this_moduleDefects->cd();
    for (unsigned int i=0; i<defects.size(); ++i) {    //loop on the number of all kinds of defects per module
      this_moduleDefects->cd();
      

      TDirectory* this_defect = (TDirectory*) gDirectory->Get(defects[i]->getName().c_str()); 
      if (!this_defect) {
    cout<<defects[i]->getName().c_str()<<" doesn't exist"<<endl;
    this_defect =gDirectory ->mkdir(defects[i]->getName().c_str());
      }
      this_defect->cd();
      
      TObjString* sdefect = new TObjString(defects[i]->getDescription().c_str());
      sdefect->Write("Defect Desctiption");
      
      /* VERY SLOW

      TVector* vStartChannel = new TVector(1,1,defects[i]->getModuleElement().getFirst(),"END");
      vStartChannel->Write("Start Channel");
      TVector* vNChannels = new TVector(1,1,defects[i]->getModuleElement().getNChannels(),"END");
      vNChannels->Write("Number of Channels");
      TVector* vChipDefect = new TVector(1,1,defects[i]->isChipDefect(),"END");   //bool
      vChipDefect->Write("isChipDefect");
      TVector* vLinkDefect = new TVector(1,1,defects[i]->isLinkDefect(),"END");   //bool
      vLinkDefect->Write("isLinkDefect");

      delete vStartChannel;
      delete vNChannels;
      delete vChipDefect;
      delete vLinkDefect;
      
      */

      //AT: New code to speed up    
      double first = defects[i]->getModuleElement().getFirst();
      double Nchannels = defects[i]->getModuleElement().getNChannels();
      double chipDefect = defects[i]->isChipDefect();
      double linkDefect = defects[i]->isLinkDefect();

      TVector* vthisDefect = new TVector(0,3, first, Nchannels,chipDefect, linkDefect, "END"); 
      vthisDefect->Write("Defect");
     
      delete sdefect;
      delete vthisDefect;
      
      
    }
  
    


    
    
    /* Making TestType   */
    //cout<<"I am making TestType Dir "<<endl;
    this_module->cd();  //make this_module the current directory 
    TDirectory* this_testType = (TDirectory*) gDirectory->Get(testType.c_str());
    //cout<<"The test Type is "<< testType <<endl;
    
    if (!this_testType) {
      //cout<<"This NEW test "<< testType <<" doesn't exist"<<endl;
      this_testType = gDirectory->mkdir(testType.c_str());
    }
    this_testType->cd();



    /* Saving Test Data: ModuleDefects */
    //for (vector<const ModuleDefect*>::iterator i = defects.begin(); i!=defects.end(); i++) {
    //  (*i)->Write(DefectsID.c_str());
    //}

    
    
    /* CLOSING FILE  */
    //cout << "I am Closing File " << endl;
    storage_file->Close();
    delete storage_file;
    //cout << "File closed " << endl;
}






void ArchTestResult::AddTestToIndex()  {
  
  /* Append current Test to the Index */

  //cout << "I am in AddTestToIndex() " << endl;
  string index = names->getIndexFileName(); 
  ofstream index_file;
  index_file.open(index.c_str(),ios::app);  //append the Index File
  //assure(out, "Strfile.out");  //TO DO

  string indexTestName = names->getRunID() + ".";
  indexTestName = indexTestName + names->getModuleID();
  indexTestName = indexTestName + ".";
  indexTestName = indexTestName + names->getTestType() + ".";
  //cout << indexTestName <<endl;
  //if(TestIsPersisted()) {
   index_file << indexTestName <<endl;
   cout << "Test appended to Index"<<endl;    
  //} else {
  //  cout<<"Test NOT correctly saved in the archive...test NOT added to the Index"<<endl;
  //}
  
  index_file.close(); 
  
}

---