///////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////
#include "TFile.h"
#include "TTree.h"
#include "TBranch.h"

#include "CompModel/TCompModel.hh"

ClassImp(TCompModel)

namespace {
  double kCpuScaleFactor_2005 = 1.267;        // 
  double kSf2                 = 22.414/5.8*(6./5.8);   // 
};

//_____________________________________________________________________________
TCompModel::TCompModel() {

  fCdf       = new TDetectorModel   ();
  fFarm      = new TProdFarmModel   ();
  fTev       = new Tevatron         ();
  fTape      = new TTapeRobotModel  ();
  fCaf       = new TCafModel        ();
  fDisk      = new TDiskStorageModel();
//-----------------------------------------------------------------------------
// fModel = 1: incremental
//        = 2: proportional
//-----------------------------------------------------------------------------
  fModel              = 1;
  fT0                 = 2005;
  fDiskVolume_2005    = -1;
//-----------------------------------------------------------------------------
// with non-optimized executable it takes ~8.9sec on 3.2 GHz GPU (ncdf192)
// to generate a Z->ee event (test dataset cdfpewk.zewkad job=1)
// use 30 GHz sec...
//
// optimized executable consumes 5.6 sec/event , improvement by a factor of 1.6
// use 18 GHz sec starting from 2006
//-----------------------------------------------------------------------------
  fCpuTimePerMcEvent  = 30.;   // in GHz*sec
}

//_____________________________________________________________________________
TCompModel::~TCompModel() {
  delete fCdf;
  delete fTev;
  delete fFarm;
}

//_____________________________________________________________________________
float TCompModel::CslEventSize(int Year) {
  // average event size out of the data logger, which compresses the events

  float event_size, lumi;

  lumi       = fTev->AverageInstLumi(Year);
  event_size = fCdf->CslEventSize(Year,lumi);

  return event_size;
}

//_____________________________________________________________________________
float TCompModel::RecoEventSize(int Year) {
  // average event size out of Production including all the overlaps
  // assume that it was constant
  // this is not quite right for the past

  float event_size, lumi;

  lumi       = fTev->AverageInstLumi(Year);
  event_size = fCdf->CslEventSize(2005,lumi)*1.4;

  return event_size;
}

//_____________________________________________________________________________
float TCompModel::McEventSize(int Year) {
  // assume that it was constant

  float event_size;

  event_size = RecoEventSize(Year)*1.3;

  return event_size;
}

//_____________________________________________________________________________
float TCompModel::NL3Events(int Year) {
  // expected number of the events out of Level3
  // model = 0: scale with the dataset size
  //       = 1: first principles, 200Hz in the end
  //       = 2: first principles, 100Hz in the end
  
  float nev, lumi, acc_eff, l3_rate_hz;

  lumi       = fTev->DeliveredLumi(Year);
  acc_eff    = fTev->OpsEff(Year);
  l3_rate_hz = fCdf->L3Rate(Year);

  nev = l3_rate_hz*kSecondsPerYear*fTev->OpsEff(Year)*fCdf->OpsEff(Year);

  return nev;
}

//_____________________________________________________________________________
float TCompModel::TotalNL3Events(int Year) {
  
  float nev(0);

  for (int i=2002; i<=Year; i++) {
    nev += NL3Events(Year);
  }

  return nev;
}

//_____________________________________________________________________________
float TCompModel::NCslEvents(int Year) {
  // expected number of the events out of the CSL (1.1 - overlap) - this 
  // ratio holds very well
  
  float nev = NL3Events(Year)*1.1;
				// normalize N(raw 2005) to 140TB
  if (Year == 2005) nev *= (140/134.);

  return nev;
}

//_____________________________________________________________________________
float TCompModel::TotalNCslEvents(int Year) {
  // expected number of the events out of the CSL (1.1 - overlap) - this 
  // ratio holds very well
  
  float nev(0), n1;

  for (int i=2002; i<=Year; i++) {
    
    n1 = NL3Events(Year)*1.1;
				// normalize N(raw 2005) to 140TB
    if (Year == 2005) n1 *= (140/134.);
    nev += nev;
  }

  return nev;
}

//_____________________________________________________________________________
float TCompModel::NReconstructedEvents(int Year) {
  // expected number of the events out of Production accounting for overlaps
  // between the streams but also assuming that only compressed B-datasets 
  // will be processed
  
  float nev = NCslEvents(Year)*1.4;

  return nev;
}

//_____________________________________________________________________________
float TCompModel::TotalNReconstructedEvents(int Year) {
  // expected number of the events out of Production accounting for overlaps
  // between the streams but also assuming that only compressed B-datasets 
  // will be processed
  
  float nev(0);

  for (int i=2002; i<=Year; i++) {
    nev += NCslEvents(Year)*1.4;
  }

  return nev;
}

//_____________________________________________________________________________
float TCompModel::NMcEvents(int Year) {
  // expected number of the MC events - 0.8 times the number of the 
  // reconstructed events, 0.8 is a 'best guess' factor
  
  float nev;

  nev = 0.8*NL3Events(Year);

  return nev;
}

//_____________________________________________________________________________
float TCompModel::TotalNMcEvents(int Year) {
  // expected number of the MC events - 0.5 times the number of the 
  // reconstructed events
  
  float nev(0);

  for (int i=2002; i<=Year; i++) {
    nev += 0.8*NL3Events(Year);
  }

  return nev;
}

//_____________________________________________________________________________
float TCompModel::McCpuNeeds(int Year) {
  // assume <time/event> = 30 GHz*sec, 
  // 600 Mln events in 2005 and that all the data need to be generated 
  // in 4 months, then scale linearly with the dataset size
  // in THz
  // scale CPU needs to get the needs of FY'2005
  // starting from 2007 plan to produce all the MC using optimized executable

  float cpu, sf, time_per_event, generation_time, contingency;

  if (Year <= 2006) time_per_event = fCpuTimePerMcEvent;
  else              time_per_event = fCpuTimePerMcEvent/1.6;

  if (fModel == 1) {
//-----------------------------------------------------------------------------
// incremental model
//-----------------------------------------------------------------------------
    if (Year <= 2006) {
      generation_time = kSecondsPerDay*30*2.;  // 2 months
      contingency     = 1;
    }
    else {
      generation_time = kSecondsPerDay*30*6;  // DC load over the year, 2 reprocessings
      contingency     = 2;
    }
    cpu = contingency*fCpuTimePerMcEvent*NMcEvents(Year)/generation_time/1.e3;
    cpu = cpu/kCpuScaleFactor_2005;
  }
  else if (fModel == 2) {
    //-----------------------------------------------------------------------------
// proportional model: normalize for year fT0, for others - scale with the 
// dataset size
//-----------------------------------------------------------------------------
    if (Year == fT0) {
				// normalization point 

      cpu = fCpuTimePerMcEvent*NMcEvents(Year)/(kSecondsPerDay*30*2.)/1.e3;
      cpu = cpu/kCpuScaleFactor_2005;
   }
    else {
      sf  = TotalDataSize(Year)/TotalDataSize(fT0);
      cpu = McCpuNeeds(fT0)*sf;
    }
  }

  return cpu/fCdf->PhysicsPerCpu(Year);
}

//_____________________________________________________________________________
float TCompModel::AnalysisCpuNeeds(int Year) {
  // analysis needs are proportional to the dataset size
  // normalize to 2005

  float nev, cpu, high_pt_fraction, sec_per_month, t_proc, t1, t2, sf, contingency;

  if (fModel == 1) {
    if (Year == fT0) {
				// 'normalization' point 

      nev           = NReconstructedEvents(Year)+NMcEvents(Year);
      sec_per_month = kSecondsPerDay*30.;

      cpu           = 1.0;
    }
    else {
      sf            = TotalDataSize(Year)/TotalDataSize(fT0);
      cpu           = AnalysisCpuNeeds(fT0)*sf;
    }
  }

  return cpu/fCdf->PhysicsPerCpu(Year);
}

//_____________________________________________________________________________
float TCompModel::NtuplingCpuNeeds(int Year) {
  // requirements: 70% of the reconstructed dataset need to be ntupled 
  //               with 3 GHz*sec/event
  //             : 30% of the dataset - with 10 GHz*sec/event
  // 
  // everything has to be done in 1 month (based on the CAF monitoring data 
  // and assuming that in the peak ntupling consumes all the CAF)
  // in THz
  // scale CPU needs to get the needs of FY'2005

  float nev, cpu, high_pt_fraction, sec_per_month, t_proc, t1, t2, sf, contingency;

  if (fModel == 1) {
    //    if (Year == fT0) {
				// 'normalization' point 

      nev           = NReconstructedEvents(Year)+NMcEvents(Year)/fCdf->PhysicsPerCpu(Year);
      sec_per_month = kSecondsPerDay*30.;

      if      (Year <   2006) {
	t_proc           = 2*sec_per_month;
	high_pt_fraction = 1;
	contingency      = 2.;
      }
      else if (Year ==  2006) {
	t_proc           = 2*sec_per_month;  // remake this year ntuples in 2 months
	high_pt_fraction = 0.8;
	contingency      = 1.0;
      }
      else if (Year  > 2006) {
	t_proc           = 6*sec_per_month;
	high_pt_fraction = 0.8;
	contingency      = 1.0;
      }

      t1 =  3.*(1 + 0.15*(fTev->AverageInstLumi(Year)-fTev->AverageInstLumi(2005)));
      t2 = 10.*(1 + 0.15*(fTev->AverageInstLumi(Year)-fTev->AverageInstLumi(2005)));

      cpu = nev*(high_pt_fraction*t1 + 
		 (1-high_pt_fraction)*t2)/t_proc/1.e3/fCaf->OpsEff(Year);

				// include contingency factor

      cpu = contingency*cpu/kCpuScaleFactor_2005;

//     }
//     else {
// 				// scale proportionally to the dataset size

//       sf  = TotalDataSize(Year)/TotalDataSize(fT0);
//       cpu = AnalysisCpuNeeds(fT0)*sf;
//     }
  }

  return cpu;
}


//-----------------------------------------------------------------------------
// production farm
//-----------------------------------------------------------------------------
float TCompModel::ReconstructionCpuNeeds(int Year) {
  // in THz

  float sf, cpu, nev, scale;

  if (fModel == 1) {
    nev = NCslEvents(Year);
    scale = 1./kCpuScaleFactor_2005;
  }
  if (fModel == 2) {
    nev = TotalNCslEvents(Year);
    scale = 1./kCpuScaleFactor_2005/kSf2;
  }

  if (fModel == 1) {
//-----------------------------------------------------------------------------
// 'incremental' model
//-----------------------------------------------------------------------------
    sf  = (fFarm->ReprocessingFactor(Year)+1)/fFarm->OpsEff(Year);
    cpu = NCslEvents(Year)*CpuTimePerEvent(Year)*sf/kSecondsPerYear/1.e3;
  }
  else if (fModel== 2) {
    if (Year == fT0) {
				// 'normalization' point 

      sf  = (fFarm->ReprocessingFactor(Year)+1)/fFarm->OpsEff(Year);
      cpu = NCslEvents(Year)*CpuTimePerEvent(Year)*sf/kSecondsPerYear/1.e3;
    }
    else {
				// scale proportionally to the dataset size

      sf  = TotalDataSize(Year)/TotalDataSize(fT0);
      cpu = ReconstructionCpuNeeds(fT0)*sf;
    }
  }

  return cpu;
}

//-----------------------------------------------------------------------------
float TCompModel::TotalCpuNeeds(int Year) {
  float cpu;

  cpu = ReconstructionCpuNeeds(Year)+McCpuNeeds(Year)+
        NtuplingCpuNeeds(Year)+AnalysisCpuNeeds(Year);

  return cpu;
}

//-----------------------------------------------------------------------------
float TCompModel::RetiredCpu(int Year) {
  float cpu;

  cpu = fFarm->RetiredCpu(Year)+fCaf->RetiredCpu(Year);

  return cpu;
}

//-----------------------------------------------------------------------------
float TCompModel::OnsiteCpu(int Year) {
  float cpu;

  cpu = fFarm->CpuTotal(Year)+fCaf->CpuTotal(Year);

  // kludge to avoid unreasonable numbers for 2002-2003 where they can't be 
  // calculated reliably

  if (Year == 2003) cpu = 2.5;
  if (Year == 2002) cpu = 1.8;

  return cpu;
}

//_____________________________________________________________________________
float TCompModel::CpuTimePerEvent(int Year) {
  // average reconstruction CPU time per event, GHz*sec
  
  float cpu, lumi;

  lumi = fTev->AverageInstLumi(Year);
  cpu  = fFarm->CpuTimePerEvent(lumi);

  return cpu;
}

//_____________________________________________________________________________
float TCompModel::RawDataSize(int Year) {
  // in GBytes, so assume everything is in KBytes, not in bytes
  // RAW data includes non-processed part
  
  float sz = CslEventSize(Year)*NCslEvents(Year)/fCdf->ProcessedFraction(Year)/1024./1024;

  return sz;
}

//_____________________________________________________________________________
float TCompModel::RecoDataSize(int Year) {
  // in TBytes
  
  float sz = RecoEventSize(Year)*NCslEvents(Year)/1024/1024;

  return sz;
}

//_____________________________________________________________________________
float TCompModel::McDataSize(int Year) {
  // MC data volume to be generated in FY 'Year' in TBytes
  // assume the same number of events and total size of MC event being 30%
  // larger htatn that of the data event

  float sz;

  sz = McEventSize(Year)*NMcEvents(Year)/1024/1024.;

  return sz;
}

//_____________________________________________________________________________
float TCompModel::NtupleDataSize(int Year) {
  // in GBytes, so assume everything is in KBytes, not in bytes
  // assume size of the ntuple event to be 30% of the data/MC event size
  
  float sz(0);

  if (Year > 2003) {
    sz = 0.3*(McDataSize(Year)+RecoDataSize(Year));
  }

  return sz;
}

//_____________________________________________________________________________
float TCompModel::DataSize(int Year) {
  // this includes all kinds of data written to tape in a given 'Year'
  
  float total(0), raw(0), processed(0), mc, ntuples;

  raw       = RawDataSize          (Year);
  processed = RecoDataSize         (Year); // raw*1.4;
  mc        = McDataSize           (Year);
  ntuples   = NtupleDataSize       (Year);

  total     = raw+processed+mc+ntuples;

  return total;

}

//_____________________________________________________________________________
float TCompModel::TotalRawDataSize(int Year) {
  // 
  float total(0);

  for (int year=kYear; year<=Year; year++) {
    total += RawDataSize(year);
  }

  return total;
}

//_____________________________________________________________________________
float TCompModel::TotalRecoDataSize(int Year) {
  // 
  float total(0);

  for (int year=kYear; year<=Year; year++) {
    total += RecoDataSize(year);
  }

  return total;
}

//_____________________________________________________________________________
float TCompModel::TotalMcDataSize(int Year) {
  // Total MC data volume archived including MC generated in FY 'Year' in TBytes

  float sz(0);

  for (int year=kYear; year<=Year; year++) {
    sz += McDataSize(year);
  }

  return sz;
}

//_____________________________________________________________________________
float TCompModel::TotalNtupleDataSize(int Year) {
  // 
  float total(0);

  for (int year=kYear; year<=Year; year++) {
    total += NtupleDataSize(year);
  }

  return total;
}

//_____________________________________________________________________________
float TCompModel::TotalDataSize(int Year) {
  // total data volume generated by CDF up and including 'Year'
  // total   = raw + processed + mc + ntuples
  // in TBytes, I believe
  
  float total(0);

  for (int year=kYear; year<=Year; year++) {
    total += DataSize(year);
  }

  return total;
}

//-----------------------------------------------------------------------------
// tape subsystem
//_____________________________________________________________________________
float TCompModel::TapeBandwidth(int Year) {
  // minimal requirements to the total tape bandwidth
  
  float bw(0), scale(1.), data_volume;
//-----------------------------------------------------------------------------
// write raw data , read it back to run Production
//-----------------------------------------------------------------------------
  data_volume = 2*DataSize(Year);
//-----------------------------------------------------------------------------
// write output of Production and produced MONTE CARLO , then read them back
// to make ntuples
//-----------------------------------------------------------------------------
  data_volume += 2*(RecoDataSize(Year)+ McDataSize(Year));
//-----------------------------------------------------------------------------
// finally write ntuples to tape and rad them back to store on disk
//-----------------------------------------------------------------------------
  data_volume += 2*NtupleDataSize(Year);
//-----------------------------------------------------------------------------
// as data volumes are in TBytes, convert the result to MBytes/sec
//-----------------------------------------------------------------------------
  bw = fTape->TotalBandwidth(2005)*scale/kSecondsPerYear/1024/1024;

  return bw;
}

//-----------------------------------------------------------------------------
// disk storage subsystem
//_____________________________________________________________________________
float TCompModel::ProjectedDiskVolume(int Year) {

  float vol(0), scale(1.), sf_vol, sf_cpu;

  if (fModel == 1) {
    if (Year == 2006) vol = 710;
    else {
//-----------------------------------------------------------------------------
// 2 components: dataset size and rate - from 2006 data:
// 370(Dcache)+20(farm)+35(MC)+40(other) - scale as rate
// 200(physics)+80(pool) - scale as data volume
// this means : 450/700 as CPU , 250/700 as volume
//------------------------------------------------------------------------------
      sf_vol  = TotalDataSize(Year)/TotalDataSize(2006);
      sf_cpu  = TotalCpuNeeds(Year)/TotalCpuNeeds(2006);

      vol = 455*sf_cpu + 255*sf_vol;
    }
  }
  else if (fModel == 2) {

    scale = TotalDataSize(Year)/TotalDataSize(fT0);

    if (fDiskVolume_2005 < 0.) {
      vol   = fDisk->TotalVolume(2005)*scale;
    }
    else {
      vol   = fDiskVolume_2005*scale;
    }

    if (Year == 2006) vol = 710;
  }

  return vol;
}

//_____________________________________________________________________________
float TCompModel::AvailableDiskVolume(int Year) {

  float vol(0), scale(1.);

  vol   = fDisk->TotalVolume(Year);

  return vol;
}