[u/mrichter/AliRoot.git] / PWG3 / dielectron / AliDielectronCF.cxx

/*************************************************************************
* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/

///////////////////////////////////////////////////////////////////////////
//       Dielectron Correction framework manager                         //
//                                                                       //
/*


*/
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#include <TList.h>
#include <TObjArray.h>
#include <TVectorD.h>

#include <AliCFContainer.h>
#include <AliAnalysisFilter.h>
#include <AliAnalysisCuts.h>
#include <AliVParticle.h>
#include <AliLog.h>

#include "AliDielectronCF.h"
#include "AliDielectronMC.h"
#include "AliDielectronPair.h"

ClassImp(AliDielectronCF)

AliDielectronCF::AliDielectronCF() :
  TNamed("DielectronCF","DielectronCF"),
  fNSteps(0),
  fNVars(0),
  fVarBinLimits(0x0),
  fNVarsLeg(0),
  fNCuts(0),
  fValues(0x0),
  fStepForMCtruth(kFALSE),
  fStepForNoCutsMCmotherPid(kFALSE),
  fStepForAfterAllCuts(kTRUE),
  fStepsForEachCut(kFALSE),
  fStepsForCutsIncreasing(kFALSE),
  fStepsForSignal(kTRUE),
  fStepsForBackground(kFALSE),
  fNStepMasks(0),
  fPdgMother(-1),
  fCfContainer(0x0),
  fHasMC(kFALSE),
  fNAddSteps(0)
{
  //
  // Default constructor
  //
  for (Int_t i=0; i<AliDielectronVarManager::kNMaxValues; ++i){
    fVariables[i]=0;
    fVariablesLeg[i]=0;
  }

  for (Int_t i=0; i<kNmaxAddSteps; ++i){
    fNBins[i]=0;
    fVarLoLimit[i]=0.;
    fVarUpLimit[i]=0.;
    fNBinsLeg[i]=0;
    fVarLoLimitLeg[i]=0.;
    fVarUpLimitLeg[i]=0.;
    fStepMasks[i]=0xFFFFFF;
  }
}

//________________________________________________________________
AliDielectronCF::AliDielectronCF(const char* name, const char* title) :
  TNamed(name, title),
  fNSteps(0),
  fNVars(0),
  fVarBinLimits(0x0),
  fNVarsLeg(0),
  fNCuts(0),
  fValues(0x0),
  fStepForMCtruth(kFALSE),
  fStepForNoCutsMCmotherPid(kFALSE),
  fStepForAfterAllCuts(kTRUE),
  fStepsForEachCut(kFALSE),
  fStepsForCutsIncreasing(kFALSE),
  fStepsForSignal(kTRUE),
  fStepsForBackground(kFALSE),
  fNStepMasks(0),
  fPdgMother(-1),
  fCfContainer(0x0),
  fHasMC(kFALSE),
  fNAddSteps(0)
{
  //
  // Named constructor
  //
  for (Int_t i=0; i<AliDielectronVarManager::kNMaxValues; ++i){
    fVariables[i]=0;
    fVariablesLeg[i]=0;
  }
  
  for (Int_t i=0; i<kNmaxAddSteps; ++i){
    fNBins[i]=0;
    fVarLoLimit[i]=0.;
    fVarUpLimit[i]=0.;
    fNBinsLeg[i]=0;
    fVarLoLimitLeg[i]=0.;
    fVarUpLimitLeg[i]=0.;
    fStepMasks[i]=0xFFFFFF;
  }
}

//________________________________________________________________
AliDielectronCF::~AliDielectronCF()
{
  //
  // Destructor
  //
  if (fValues) delete [] fValues;
}

//________________________________________________________________
void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max, Bool_t leg)
{
  //
  // Add a variable to the CF configuration
  //

  if (!leg){
    if (max<min){
      Double_t tmp=min;
      min=max;
      max=tmp;
    }
    fVariables[fNVars]  = (UInt_t)type;
    fVarLoLimit[fNVars] = min;
    fVarUpLimit[fNVars] = max;
    fNBins[fNVars]      = nbins;
    ++fNVars;
  } else {
    fVariablesLeg[fNVarsLeg]  = (UInt_t)type;
    fVarLoLimitLeg[fNVarsLeg] = min;
    fVarUpLimitLeg[fNVarsLeg] = max;
    fNBinsLeg[fNVarsLeg]      = nbins;
    ++fNVarsLeg;
  }
}

//________________________________________________________________
void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, TVectorD * const binLimits)
{
  //
  // Add a variable to the CF configuration
  //
  if (!binLimits) return;
  if (!fVarBinLimits) fVarBinLimits=new TObjArray(kNmaxAddSteps);
  fVarBinLimits->AddAt(binLimits, fNVars);
  fVariables[fNVars]  = (UInt_t)type;
  fVarLoLimit[fNVars] = 2.;
  fVarUpLimit[fNVars] = 1.;
  fNBins[fNVars]      = binLimits->GetNrows()-1;
  ++fNVars;
}

//________________________________________________________________
void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
{
  //
  // Initialise container based on the cuts in the analysis filter
  //

  fNCuts=filter.GetCuts()->GetEntries();

  fHasMC=AliDielectronMC::Instance()->HasMC();
  fNAddSteps=1;
  if (fHasMC){
    if (fStepsForSignal) ++fNAddSteps;
    if (fStepsForBackground) ++fNAddSteps;
  } else {
    //if 
    fStepForMCtruth=kFALSE;
    fStepForNoCutsMCmotherPid=kFALSE;
    fStepsForSignal=kFALSE;
    fStepsForBackground=kFALSE;
  }
    
  fNSteps=0;
  if (fStepForMCtruth) ++fNSteps;
  if (fStepForNoCutsMCmotherPid) ++fNSteps;
  if (fStepForAfterAllCuts) fNSteps+=fNAddSteps;

  if (fStepsForEachCut&&fNCuts>1)        fNSteps+=(fNAddSteps*fNCuts);     //one step for each cut + Signal (MC)
  if (fStepsForCutsIncreasing&&fNCuts>2) fNSteps+=(fNAddSteps*(fNCuts-2)); //one step for the increasing cuts + Signal (MC)
                                                      // e.g. cut2&cut3, cut2&cut3&cut4
  fNSteps+=(fNAddSteps*fNStepMasks);                            // cuts for the additional cut masks
  // create the container
  Int_t *nbins=new Int_t[fNVars+2*fNVarsLeg];
  for (Int_t i=0;i<fNVars;++i)    nbins[i]=fNBins[i];
  for (Int_t i=0;i<fNVarsLeg;++i) nbins[i+fNVars]=fNBinsLeg[i];
  for (Int_t i=0;i<fNVarsLeg;++i) nbins[i+fNVars+fNVarsLeg]=fNBinsLeg[i];
  
  fCfContainer = new AliCFContainer(GetName(), GetTitle(), fNSteps, fNVars+2*fNVarsLeg, nbins);
  delete [] nbins;
  
  // initialize the variables and their bin limits
  for (Int_t iVar=0; iVar<fNVars; iVar++) {
    UInt_t type=fVariables[iVar];
    Int_t    nBins = fNBins[iVar];
    Double_t loLim = fVarLoLimit[iVar];
    Double_t upLim = fVarUpLimit[iVar];
    Double_t *binLim = 0x0;

    if (upLim<loLim) {
      if (!fVarBinLimits) {
        AliError(Form("Expected variable bin limits for variable %d (%s)",
                      iVar,AliDielectronVarManager::GetValueName(type)));
        continue;
      }
      if (!fVarBinLimits->At(iVar)) {
        AliError(Form("Expected variable bin limits for variable %d (%s)",
                      iVar,AliDielectronVarManager::GetValueName(type)));
        continue;
      }
      binLim=(static_cast<TVectorD*>(fVarBinLimits->At(iVar)))->GetMatrixArray();
    } else {
      binLim=new Double_t[nBins+1];
      // set the bin limits
      for(Int_t iBin=0; iBin<=nBins; iBin++) binLim[iBin] = loLim + (upLim-loLim) / nBins*(Double_t)iBin;
    }
    fCfContainer->SetBinLimits(iVar, binLim);
    fCfContainer->SetVarTitle(iVar, AliDielectronVarManager::GetValueName(type));
    if ( upLim>loLim ) delete [] binLim;
  }
  
  // initialize the variables and their bin limits for the Legs
  for (Int_t iVar=0; iVar<fNVarsLeg; iVar++) {
    UInt_t type=fVariablesLeg[iVar];
    Int_t    nBins = fNBinsLeg[iVar];
    Double_t loLim = fVarLoLimitLeg[iVar];
    Double_t upLim = fVarUpLimitLeg[iVar];
    Double_t *binLim = new Double_t[nBins+1];
    
    // set the bin limits
    for(Int_t iBin=0; iBin<=nBins; iBin++) binLim[iBin] = loLim + (upLim-loLim) / nBins*(Double_t)iBin;

    //Leg1
    fCfContainer->SetBinLimits(iVar+fNVars, binLim);
    fCfContainer->SetVarTitle(iVar+fNVars, Form("Leg1_%s",AliDielectronVarManager::GetValueName(type)));
    
    //Leg2
    fCfContainer->SetBinLimits(iVar+fNVars+fNVarsLeg, binLim);
    fCfContainer->SetVarTitle(iVar+fNVars+fNVarsLeg, Form("Leg2_%s",AliDielectronVarManager::GetValueName(type)));
    
    delete [] binLim;
  }

  // array for storing values
  fValues = new Double_t[fNVars+2*fNVarsLeg];
  
  //=================//
  // Set step titles //
  //=================//
  Int_t step=0;

  //Pure MC truth
  if (fStepForMCtruth){
    fCfContainer->SetStepTitle(step++,"MC truth");
  }

  //before cuts (MC truth)
  if (fStepForNoCutsMCmotherPid){
    fCfContainer->SetStepTitle(step++,"No cuts (Signal)");
  }
  
  TString cutName;
  //Steps for each of the cuts
  if (fStepsForEachCut&&fNCuts>1){
    for (Int_t iCut=0; iCut<fNCuts;++iCut) {
      cutName=filter.GetCuts()->At(iCut)->GetName(); //TODO: User GetTitle???
      
      fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
      
      if (fHasMC){
        if (fStepsForSignal)
          fCfContainer->SetStepTitle(step++, (cutName+" (Signal)").Data()); //Step for the cut with MC truth
        if (fStepsForBackground)
          fCfContainer->SetStepTitle(step++, (cutName+" (Background)").Data()); //Step for the cut with MC truth
      }
    }
  }

  //Steps for increasing cut match
  if (fStepsForCutsIncreasing&&fNCuts>2){
    cutName=filter.GetCuts()->At(0)->GetName(); //TODO: User GetTitle???
    for (Int_t iCut=1; iCut<fNCuts-1;++iCut) {
      cutName+="&";
      cutName+=filter.GetCuts()->At(iCut)->GetName();
      
      fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
      
      if (fHasMC){
        if (fStepsForSignal)
          fCfContainer->SetStepTitle(step++, (cutName+" (Signal)").Data()); //Step for the cut with MC truth
        if (fStepsForBackground)
          fCfContainer->SetStepTitle(step++, (cutName+" (Background)").Data()); //Step for the cut with MC truth
      }
    }
  }

  //Steps of user defined cut combinations
  for (UInt_t iComb=0; iComb<fNStepMasks; ++iComb){
    cutName="";
    UInt_t mask=fStepMasks[iComb];
    for (Int_t iCut=0; iCut<fNCuts;++iCut) {
      if (mask&(1<<iCut)){
        if (cutName.IsNull()){
          cutName=filter.GetCuts()->At(iCut)->GetName();
        }else{
          cutName+="&";
          cutName+=filter.GetCuts()->At(iCut)->GetName();
        }
      }
    }
    
    fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
    
    if (fHasMC){
      if (fStepsForSignal)
        fCfContainer->SetStepTitle(step++, (cutName+" (Signal)").Data()); //Step for the cut with MC truth
      if (fStepsForBackground)
        fCfContainer->SetStepTitle(step++, (cutName+" (Background)").Data()); //Step for the cut with MC truth
    }
  }

  //After All cuts
  if (fStepForAfterAllCuts){
    cutName="No pair cuts";
    if (filter.GetCuts()->At(0)){
      cutName=filter.GetCuts()->At(0)->GetName(); //TODO: User GetTitle???
      for (Int_t iCut=1; iCut<fNCuts;++iCut) {
        cutName+="&";
        cutName+=filter.GetCuts()->At(iCut)->GetName();
      }
    }
    fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
    if (fHasMC){
      if (fStepsForSignal)
        fCfContainer->SetStepTitle(step++, (cutName+" (Signal)").Data()); //Step for the cut with MC truth
      if (fStepsForBackground)
        fCfContainer->SetStepTitle(step++, (cutName+" (Background)").Data()); //Step for the cut with MC truth
    }
  }

  if (step!=fNSteps) {
    AliError(Form("Something went wrong in the naming of the steps!!! (%d != %d)",step,fNSteps));
  }
}

//________________________________________________________________
void AliDielectronCF::Fill(UInt_t mask, const AliDielectronPair *particle)
{
  //
  // Fill the containers
  //

  Bool_t isMCTruth=kFALSE;
  if (fHasMC) isMCTruth=AliDielectronMC::Instance()->IsMotherPdg(particle,fPdgMother);

  Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
  AliDielectronVarManager::Fill(particle,valuesPair);

  for (Int_t iVar=0; iVar<fNVars; ++iVar){
    Int_t var=fVariables[iVar];
    fValues[iVar]=valuesPair[var];
  }

  if (fNVarsLeg>0){
    Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues];
    AliDielectronVarManager::Fill(particle->GetFirstDaughter(),valuesLeg1);
    Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues];
    AliDielectronVarManager::Fill(particle->GetSecondDaughter(),valuesLeg2);

    for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
      Int_t var=fVariablesLeg[iVar];
      fValues[iVar+fNVars]=valuesLeg1[var];
      fValues[iVar+fNVars+fNVarsLeg]=valuesLeg2[var];
    }
  }
  
  UInt_t selectedMask=(1<<fNCuts)-1;

  //============//
  // Fill steps //
  //============//
  // step 0 would be full MC truth and is handled in FillMC
  Int_t step=0;
  if (fStepForMCtruth) ++step;
  
  //No cuts (MC truth)
  if (fStepForNoCutsMCmotherPid){
    if (isMCTruth) fCfContainer->Fill(fValues,step);
    ++step;
  }
  
  //Steps for each of the cuts
  if (fStepsForEachCut&&fNCuts>1){
    for (Int_t iCut=0; iCut<fNCuts;++iCut) {
      if (mask&(1<<iCut)) {
        fCfContainer->Fill(fValues,step);
        ++step;

        if (fHasMC){
          if ( fStepsForSignal){
            if (isMCTruth) fCfContainer->Fill(fValues,step);
            ++step;
          }
          if ( fStepsForBackground ){
            if (!isMCTruth) fCfContainer->Fill(fValues,step);
            ++step;
          }
        }
      } else {
        step+=fNAddSteps;
      }
    }
  }

  //Steps for increasing cut match
  if (fStepsForCutsIncreasing&&fNCuts>2){
    for (Int_t iCut=1; iCut<fNCuts-1;++iCut) {
      if (mask&(1<<((iCut+1)-1))) {
        fCfContainer->Fill(fValues,step);
        ++step;
        
        if (fHasMC){
          if ( fStepsForSignal){
            if (isMCTruth) fCfContainer->Fill(fValues,step);
            ++step;
          }
          if ( fStepsForBackground ){
            if (!isMCTruth) fCfContainer->Fill(fValues,step);
            ++step;
          }
        }
      } else {
        step+=fNAddSteps;
      }
    }
  }

  //Steps of user defined cut combinations
  for (UInt_t iComb=0; iComb<fNStepMasks; ++iComb){
    UInt_t userMask=fStepMasks[iComb];
    if (mask&userMask) {
      fCfContainer->Fill(fValues,step);
      ++step;
      
      if (fHasMC){
        if ( fStepsForSignal){
          if (isMCTruth) fCfContainer->Fill(fValues,step);
          ++step;
        }
        if ( fStepsForBackground ){
          if (!isMCTruth) fCfContainer->Fill(fValues,step);
          ++step;
        }
      }
    } else {
      step+=fNAddSteps;
    }
  }
  
  //All cuts
  if (fStepForAfterAllCuts){
    if (mask == selectedMask){
      fCfContainer->Fill(fValues,step);
      ++step;
      
      if (fHasMC){
        if ( fStepsForSignal){
          if (isMCTruth) fCfContainer->Fill(fValues,step);
          ++step;
        }
        if ( fStepsForBackground ){
          if (!isMCTruth) fCfContainer->Fill(fValues,step);
          ++step;
        }
      }
    } else {
      step+=fNAddSteps;
    }
  }
  
  if (step!=fNSteps) {
    AliError("Something went wrong in the step filling!!!");
  }
  
}

//________________________________________________________________
void AliDielectronCF::FillMC(const TObject *particle)
{
  //
  // fill MC part of the Container
  //
  if (!fStepForMCtruth) return;
  
  Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
  AliDielectronVarManager::Fill(particle,valuesPair);

  AliVParticle *d1=0x0;
  AliVParticle *d2=0x0;
  AliDielectronMC::Instance()->GetDaughters(particle,d1,d2);
  
  valuesPair[AliDielectronVarManager::kThetaHE]=AliDielectronPair::ThetaPhiCM(d1,d2,kTRUE,kTRUE);
  valuesPair[AliDielectronVarManager::kPhiHE]=AliDielectronPair::ThetaPhiCM(d1,d2,kTRUE,kFALSE);
  valuesPair[AliDielectronVarManager::kThetaCS]=AliDielectronPair::ThetaPhiCM(d1,d2,kFALSE,kTRUE);
  valuesPair[AliDielectronVarManager::kPhiCS]=AliDielectronPair::ThetaPhiCM(d1,d2,kFALSE,kFALSE);
  
  //TODO: temporary solution, set manually the pair type to 1: unlikesign SE
  valuesPair[AliDielectronVarManager::kPairType]=1;
  
  for (Int_t iVar=0; iVar<fNVars; ++iVar){
    Int_t var=fVariables[iVar];
    fValues[iVar]=valuesPair[var];
  }
  
  if (fNVarsLeg>0){
    Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues];
    Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues];
    if (d1->Pt()>d2->Pt()){
      AliDielectronVarManager::Fill(d1,valuesLeg1);
      AliDielectronVarManager::Fill(d2,valuesLeg2);
    } else {
      AliDielectronVarManager::Fill(d2,valuesLeg1);
      AliDielectronVarManager::Fill(d1,valuesLeg2);
    }
    
    for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
      Int_t var=fVariablesLeg[iVar];
      fValues[iVar+fNVars]=valuesLeg1[var];
      fValues[iVar+fNVars+fNVarsLeg]=valuesLeg2[var];
    }
  }
  
  fCfContainer->Fill(fValues,0);
}
Commit	Line	Data
b2a297fa	1	/*************************************************************************
	2	* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	///////////////////////////////////////////////////////////////////////////
	17	// Dielectron Correction framework manager //
	18	// //
	19	/*
	20
	21
	22
	23
	24
	25
	26
	27
	28
	29	*/
	30	// //
	31	///////////////////////////////////////////////////////////////////////////
	32
	33	#include <TList.h>
61d106d3	34	#include <TObjArray.h>
61d106d3	35	#include <TVectorD.h>
b2a297fa	36
	37	#include <AliCFContainer.h>
	38	#include <AliAnalysisFilter.h>
	39	#include <AliAnalysisCuts.h>
6551594b	40	#include <AliVParticle.h>
b2a297fa	41	#include <AliLog.h>
	42
	43	#include "AliDielectronCF.h"
	44	#include "AliDielectronMC.h"
6551594b	45	#include "AliDielectronPair.h"
b2a297fa	46
	47	ClassImp(AliDielectronCF)
	48
	49	AliDielectronCF::AliDielectronCF() :
	50	TNamed("DielectronCF","DielectronCF"),
	51	fNSteps(0),
	52	fNVars(0),
61d106d3	53	fVarBinLimits(0x0),
6551594b	54	fNVarsLeg(0),
b2a297fa	55	fNCuts(0),
6551594b	56	fValues(0x0),
e123f993	57	fStepForMCtruth(kFALSE),
	58	fStepForNoCutsMCmotherPid(kFALSE),
	59	fStepForAfterAllCuts(kTRUE),
	60	fStepsForEachCut(kFALSE),
b2a297fa	61	fStepsForCutsIncreasing(kFALSE),
572b0139	62	fStepsForSignal(kTRUE),
572b0139	63	fStepsForBackground(kFALSE),
b2a297fa	64	fNStepMasks(0),
b2a297fa	65	fPdgMother(-1),
572b0139	66	fCfContainer(0x0),
	67	fHasMC(kFALSE),
	68	fNAddSteps(0)
b2a297fa	69	{
	70	//
	71	// Default constructor
	72	//
	73	for (Int_t i=0; i<AliDielectronVarManager::kNMaxValues; ++i){
	74	fVariables[i]=0;
61d106d3	75	fVariablesLeg[i]=0;
b2a297fa	76	}
	77
	78	for (Int_t i=0; i<kNmaxAddSteps; ++i){
e123f993	79	fNBins[i]=0;
	80	fVarLoLimit[i]=0.;
	81	fVarUpLimit[i]=0.;
6551594b	82	fNBinsLeg[i]=0;
	83	fVarLoLimitLeg[i]=0.;
	84	fVarUpLimitLeg[i]=0.;
e123f993	85	fStepMasks[i]=0xFFFFFF;
b2a297fa	86	}
	87	}
	88
	89	//________________________________________________________________
	90	AliDielectronCF::AliDielectronCF(const char* name, const char* title) :
	91	TNamed(name, title),
	92	fNSteps(0),
	93	fNVars(0),
61d106d3	94	fVarBinLimits(0x0),
6551594b	95	fNVarsLeg(0),
b2a297fa	96	fNCuts(0),
6551594b	97	fValues(0x0),
e123f993	98	fStepForMCtruth(kFALSE),
	99	fStepForNoCutsMCmotherPid(kFALSE),
	100	fStepForAfterAllCuts(kTRUE),
	101	fStepsForEachCut(kFALSE),
b2a297fa	102	fStepsForCutsIncreasing(kFALSE),
572b0139	103	fStepsForSignal(kTRUE),
572b0139	104	fStepsForBackground(kFALSE),
b2a297fa	105	fNStepMasks(0),
b2a297fa	106	fPdgMother(-1),
572b0139	107	fCfContainer(0x0),
	108	fHasMC(kFALSE),
	109	fNAddSteps(0)
b2a297fa	110	{
	111	//
	112	// Named constructor
	113	//
	114	for (Int_t i=0; i<AliDielectronVarManager::kNMaxValues; ++i){
	115	fVariables[i]=0;
61d106d3	116	fVariablesLeg[i]=0;
b2a297fa	117	}
	118
	119	for (Int_t i=0; i<kNmaxAddSteps; ++i){
e123f993	120	fNBins[i]=0;
	121	fVarLoLimit[i]=0.;
	122	fVarUpLimit[i]=0.;
6551594b	123	fNBinsLeg[i]=0;
	124	fVarLoLimitLeg[i]=0.;
	125	fVarUpLimitLeg[i]=0.;
e123f993	126	fStepMasks[i]=0xFFFFFF;
b2a297fa	127	}
	128	}
	129
	130	//________________________________________________________________
	131	AliDielectronCF::~AliDielectronCF()
	132	{
	133	//
	134	// Destructor
	135	//
6551594b	136	if (fValues) delete [] fValues;
b2a297fa	137	}
	138
	139	//________________________________________________________________
6551594b	140	void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max, Bool_t leg)
b2a297fa	141	{
	142	//
	143	// Add a variable to the CF configuration
	144	//
6551594b	145
6551594b	146	if (!leg){
61d106d3	147	if (max<min){
	148	Double_t tmp=min;
	149	min=max;
	150	max=tmp;
	151	}
6551594b	152	fVariables[fNVars] = (UInt_t)type;
	153	fVarLoLimit[fNVars] = min;
	154	fVarUpLimit[fNVars] = max;
	155	fNBins[fNVars] = nbins;
	156	++fNVars;
	157	} else {
	158	fVariablesLeg[fNVarsLeg] = (UInt_t)type;
	159	fVarLoLimitLeg[fNVarsLeg] = min;
	160	fVarUpLimitLeg[fNVarsLeg] = max;
	161	fNBinsLeg[fNVarsLeg] = nbins;
	162	++fNVarsLeg;
	163	}
b2a297fa	164	}
b2a297fa	165
61d106d3	166	//________________________________________________________________
	167	void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, TVectorD * const binLimits)
	168	{
	169	//
	170	// Add a variable to the CF configuration
	171	//
	172	if (!binLimits) return;
	173	if (!fVarBinLimits) fVarBinLimits=new TObjArray(kNmaxAddSteps);
	174	fVarBinLimits->AddAt(binLimits, fNVars);
	175	fVariables[fNVars] = (UInt_t)type;
	176	fVarLoLimit[fNVars] = 2.;
	177	fVarUpLimit[fNVars] = 1.;
	178	fNBins[fNVars] = binLimits->GetNrows()-1;
	179	++fNVars;
	180	}
	181
b2a297fa	182	//________________________________________________________________
	183	void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
	184	{
	185	//
	186	// Initialise container based on the cuts in the analysis filter
	187	//
	188
	189	fNCuts=filter.GetCuts()->GetEntries();
e123f993	190
572b0139	191	fHasMC=AliDielectronMC::Instance()->HasMC();
	192	fNAddSteps=1;
	193	if (fHasMC){
	194	if (fStepsForSignal) ++fNAddSteps;
	195	if (fStepsForBackground) ++fNAddSteps;
	196	} else {
	197	//if
	198	fStepForMCtruth=kFALSE;
	199	fStepForNoCutsMCmotherPid=kFALSE;
	200	fStepsForSignal=kFALSE;
	201	fStepsForBackground=kFALSE;
	202	}
	203
e123f993	204	fNSteps=0;
	205	if (fStepForMCtruth) ++fNSteps;
	206	if (fStepForNoCutsMCmotherPid) ++fNSteps;
572b0139	207	if (fStepForAfterAllCuts) fNSteps+=fNAddSteps;
	208
	209	if (fStepsForEachCut&&fNCuts>1) fNSteps+=(fNAddSteps*fNCuts); //one step for each cut + Signal (MC)
	210	if (fStepsForCutsIncreasing&&fNCuts>2) fNSteps+=(fNAddSteps*(fNCuts-2)); //one step for the increasing cuts + Signal (MC)
b2a297fa	211	// e.g. cut2&cut3, cut2&cut3&cut4
572b0139	212	fNSteps+=(fNAddSteps*fNStepMasks); // cuts for the additional cut masks
b2a297fa	213	// create the container
6551594b	214	Int_t nbins=new Int_t[fNVars+2fNVarsLeg];
	215	for (Int_t i=0;i<fNVars;++i) nbins[i]=fNBins[i];
	216	for (Int_t i=0;i<fNVarsLeg;++i) nbins[i+fNVars]=fNBinsLeg[i];
	217	for (Int_t i=0;i<fNVarsLeg;++i) nbins[i+fNVars+fNVarsLeg]=fNBinsLeg[i];
	218
	219	fCfContainer = new AliCFContainer(GetName(), GetTitle(), fNSteps, fNVars+2*fNVarsLeg, nbins);
	220	delete [] nbins;
b2a297fa	221
	222	// initialize the variables and their bin limits
	223	for (Int_t iVar=0; iVar<fNVars; iVar++) {
	224	UInt_t type=fVariables[iVar];
	225	Int_t nBins = fNBins[iVar];
	226	Double_t loLim = fVarLoLimit[iVar];
	227	Double_t upLim = fVarUpLimit[iVar];
61d106d3	228	Double_t *binLim = 0x0;
	229
	230	if (upLim<loLim) {
	231	if (!fVarBinLimits) {
	232	AliError(Form("Expected variable bin limits for variable %d (%s)",
	233	iVar,AliDielectronVarManager::GetValueName(type)));
	234	continue;
	235	}
	236	if (!fVarBinLimits->At(iVar)) {
	237	AliError(Form("Expected variable bin limits for variable %d (%s)",
	238	iVar,AliDielectronVarManager::GetValueName(type)));
	239	continue;
	240	}
	241	binLim=(static_cast<TVectorD*>(fVarBinLimits->At(iVar)))->GetMatrixArray();
	242	} else {
	243	binLim=new Double_t[nBins+1];
	244	// set the bin limits
	245	for(Int_t iBin=0; iBin<=nBins; iBin++) binLim[iBin] = loLim + (upLim-loLim) / nBins*(Double_t)iBin;
	246	}
b2a297fa	247	fCfContainer->SetBinLimits(iVar, binLim);
b2a297fa	248	fCfContainer->SetVarTitle(iVar, AliDielectronVarManager::GetValueName(type));
61d106d3	249	if ( upLim>loLim ) delete [] binLim;
6551594b	250	}
	251
	252	// initialize the variables and their bin limits for the Legs
	253	for (Int_t iVar=0; iVar<fNVarsLeg; iVar++) {
	254	UInt_t type=fVariablesLeg[iVar];
	255	Int_t nBins = fNBinsLeg[iVar];
	256	Double_t loLim = fVarLoLimitLeg[iVar];
	257	Double_t upLim = fVarUpLimitLeg[iVar];
	258	Double_t *binLim = new Double_t[nBins+1];
	259
	260	// set the bin limits
	261	for(Int_t iBin=0; iBin<=nBins; iBin++) binLim[iBin] = loLim + (upLim-loLim) / nBins*(Double_t)iBin;
	262
	263	//Leg1
	264	fCfContainer->SetBinLimits(iVar+fNVars, binLim);
	265	fCfContainer->SetVarTitle(iVar+fNVars, Form("Leg1_%s",AliDielectronVarManager::GetValueName(type)));
	266
	267	//Leg2
	268	fCfContainer->SetBinLimits(iVar+fNVars+fNVarsLeg, binLim);
	269	fCfContainer->SetVarTitle(iVar+fNVars+fNVarsLeg, Form("Leg2_%s",AliDielectronVarManager::GetValueName(type)));
	270
	271	delete [] binLim;
b2a297fa	272	}
6551594b	273
	274	// array for storing values
	275	fValues = new Double_t[fNVars+2*fNVarsLeg];
b2a297fa	276
	277	//=================//
	278	// Set step titles //
	279	//=================//
	280	Int_t step=0;
	281
	282	//Pure MC truth
e123f993	283	if (fStepForMCtruth){
8df8e382	284	fCfContainer->SetStepTitle(step++,"MC truth");
e123f993	285	}
b2a297fa	286
b2a297fa	287	//before cuts (MC truth)
e123f993	288	if (fStepForNoCutsMCmotherPid){
a655b716	289	fCfContainer->SetStepTitle(step++,"No cuts (Signal)");
e123f993	290	}
b2a297fa	291
e123f993	292	TString cutName;
b2a297fa	293	//Steps for each of the cuts
e123f993	294	if (fStepsForEachCut&&fNCuts>1){
b2a297fa	295	for (Int_t iCut=0; iCut<fNCuts;++iCut) {
37e9382d	296	cutName=filter.GetCuts()->At(iCut)->GetName(); //TODO: User GetTitle???
572b0139	297
b2a297fa	298	fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
572b0139	299
	300	if (fHasMC){
	301	if (fStepsForSignal)
	302	fCfContainer->SetStepTitle(step++, (cutName+" (Signal)").Data()); //Step for the cut with MC truth
	303	if (fStepsForBackground)
	304	fCfContainer->SetStepTitle(step++, (cutName+" (Background)").Data()); //Step for the cut with MC truth
	305	}
b2a297fa	306	}
	307	}
	308
	309	//Steps for increasing cut match
78091935	310	if (fStepsForCutsIncreasing&&fNCuts>2){
37e9382d	311	cutName=filter.GetCuts()->At(0)->GetName(); //TODO: User GetTitle???
b2a297fa	312	for (Int_t iCut=1; iCut<fNCuts-1;++iCut) {
	313	cutName+="&";
	314	cutName+=filter.GetCuts()->At(iCut)->GetName();
572b0139	315
b2a297fa	316	fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
572b0139	317
	318	if (fHasMC){
	319	if (fStepsForSignal)
	320	fCfContainer->SetStepTitle(step++, (cutName+" (Signal)").Data()); //Step for the cut with MC truth
	321	if (fStepsForBackground)
	322	fCfContainer->SetStepTitle(step++, (cutName+" (Background)").Data()); //Step for the cut with MC truth
	323	}
b2a297fa	324	}
	325	}
	326
	327	//Steps of user defined cut combinations
	328	for (UInt_t iComb=0; iComb<fNStepMasks; ++iComb){
37e9382d	329	cutName="";
b2a297fa	330	UInt_t mask=fStepMasks[iComb];
	331	for (Int_t iCut=0; iCut<fNCuts;++iCut) {
	332	if (mask&(1<<iCut)){
	333	if (cutName.IsNull()){
	334	cutName=filter.GetCuts()->At(iCut)->GetName();
	335	}else{
	336	cutName+="&";
	337	cutName+=filter.GetCuts()->At(iCut)->GetName();
	338	}
	339	}
	340	}
572b0139	341
b2a297fa	342	fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
572b0139	343
	344	if (fHasMC){
	345	if (fStepsForSignal)
	346	fCfContainer->SetStepTitle(step++, (cutName+" (Signal)").Data()); //Step for the cut with MC truth
	347	if (fStepsForBackground)
	348	fCfContainer->SetStepTitle(step++, (cutName+" (Background)").Data()); //Step for the cut with MC truth
	349	}
	350	}
	351
	352	//After All cuts
	353	if (fStepForAfterAllCuts){
	354	cutName="No pair cuts";
	355	if (filter.GetCuts()->At(0)){
	356	cutName=filter.GetCuts()->At(0)->GetName(); //TODO: User GetTitle???
	357	for (Int_t iCut=1; iCut<fNCuts;++iCut) {
	358	cutName+="&";
	359	cutName+=filter.GetCuts()->At(iCut)->GetName();
	360	}
572b0139	361	}
8df8e382	362	fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
572b0139	363	if (fHasMC){
	364	if (fStepsForSignal)
	365	fCfContainer->SetStepTitle(step++, (cutName+" (Signal)").Data()); //Step for the cut with MC truth
	366	if (fStepsForBackground)
	367	fCfContainer->SetStepTitle(step++, (cutName+" (Background)").Data()); //Step for the cut with MC truth
	368	}
b2a297fa	369	}
	370
	371	if (step!=fNSteps) {
8df8e382	372	AliError(Form("Something went wrong in the naming of the steps!!! (%d != %d)",step,fNSteps));
b2a297fa	373	}
	374	}
	375
	376	//________________________________________________________________
6551594b	377	void AliDielectronCF::Fill(UInt_t mask, const AliDielectronPair *particle)
b2a297fa	378	{
	379	//
	380	// Fill the containers
	381	//
	382
	383	Bool_t isMCTruth=kFALSE;
572b0139	384	if (fHasMC) isMCTruth=AliDielectronMC::Instance()->IsMotherPdg(particle,fPdgMother);
b2a297fa	385
6551594b	386	Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
6551594b	387	AliDielectronVarManager::Fill(particle,valuesPair);
b2a297fa	388
b2a297fa	389	for (Int_t iVar=0; iVar<fNVars; ++iVar){
b2a297fa	390	Int_t var=fVariables[iVar];
6551594b	391	fValues[iVar]=valuesPair[var];
b2a297fa	392	}
b2a297fa	393
6551594b	394	if (fNVarsLeg>0){
	395	Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues];
	396	AliDielectronVarManager::Fill(particle->GetFirstDaughter(),valuesLeg1);
	397	Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues];
	398	AliDielectronVarManager::Fill(particle->GetSecondDaughter(),valuesLeg2);
	399
	400	for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
	401	Int_t var=fVariablesLeg[iVar];
	402	fValues[iVar+fNVars]=valuesLeg1[var];
	403	fValues[iVar+fNVars+fNVarsLeg]=valuesLeg2[var];
	404	}
	405	}
	406
b2a297fa	407	UInt_t selectedMask=(1<<fNCuts)-1;
	408
	409	//============//
	410	// Fill steps //
	411	//============//
	412	// step 0 would be full MC truth and is handled in FillMC
e123f993	413	Int_t step=0;
e123f993	414	if (fStepForMCtruth) ++step;
8df8e382	415
b2a297fa	416	//No cuts (MC truth)
e123f993	417	if (fStepForNoCutsMCmotherPid){
6551594b	418	if (isMCTruth) fCfContainer->Fill(fValues,step);
b2a297fa	419	++step;
b2a297fa	420	}
e123f993	421
b2a297fa	422	//Steps for each of the cuts
e123f993	423	if (fStepsForEachCut&&fNCuts>1){
b2a297fa	424	for (Int_t iCut=0; iCut<fNCuts;++iCut) {
b2a297fa	425	if (mask&(1<<iCut)) {
6551594b	426	fCfContainer->Fill(fValues,step);
b2a297fa	427	++step;
572b0139	428
	429	if (fHasMC){
	430	if ( fStepsForSignal){
	431	if (isMCTruth) fCfContainer->Fill(fValues,step);
	432	++step;
	433	}
	434	if ( fStepsForBackground ){
	435	if (!isMCTruth) fCfContainer->Fill(fValues,step);
	436	++step;
	437	}
	438	}
b2a297fa	439	} else {
572b0139	440	step+=fNAddSteps;
b2a297fa	441	}
	442	}
	443	}
	444
	445	//Steps for increasing cut match
78091935	446	if (fStepsForCutsIncreasing&&fNCuts>2){
b2a297fa	447	for (Int_t iCut=1; iCut<fNCuts-1;++iCut) {
b2a297fa	448	if (mask&(1<<((iCut+1)-1))) {
6551594b	449	fCfContainer->Fill(fValues,step);
b2a297fa	450	++step;
572b0139	451
	452	if (fHasMC){
	453	if ( fStepsForSignal){
	454	if (isMCTruth) fCfContainer->Fill(fValues,step);
	455	++step;
	456	}
	457	if ( fStepsForBackground ){
	458	if (!isMCTruth) fCfContainer->Fill(fValues,step);
	459	++step;
	460	}
	461	}
b2a297fa	462	} else {
572b0139	463	step+=fNAddSteps;
b2a297fa	464	}
	465	}
	466	}
	467
	468	//Steps of user defined cut combinations
	469	for (UInt_t iComb=0; iComb<fNStepMasks; ++iComb){
	470	UInt_t userMask=fStepMasks[iComb];
	471	if (mask&userMask) {
6551594b	472	fCfContainer->Fill(fValues,step);
b2a297fa	473	++step;
572b0139	474
	475	if (fHasMC){
	476	if ( fStepsForSignal){
	477	if (isMCTruth) fCfContainer->Fill(fValues,step);
	478	++step;
	479	}
	480	if ( fStepsForBackground ){
	481	if (!isMCTruth) fCfContainer->Fill(fValues,step);
	482	++step;
	483	}
	484	}
	485	} else {
	486	step+=fNAddSteps;
	487	}
	488	}
	489
	490	//All cuts
	491	if (fStepForAfterAllCuts){
	492	if (mask == selectedMask){
	493	fCfContainer->Fill(fValues,step);
b2a297fa	494	++step;
572b0139	495
	496	if (fHasMC){
	497	if ( fStepsForSignal){
	498	if (isMCTruth) fCfContainer->Fill(fValues,step);
	499	++step;
	500	}
	501	if ( fStepsForBackground ){
	502	if (!isMCTruth) fCfContainer->Fill(fValues,step);
	503	++step;
	504	}
	505	}
b2a297fa	506	} else {
572b0139	507	step+=fNAddSteps;
b2a297fa	508	}
	509	}
	510
572b0139	511	if (step!=fNSteps) {
	512	AliError("Something went wrong in the step filling!!!");
	513	}
	514
b2a297fa	515	}
	516
	517	//________________________________________________________________
	518	void AliDielectronCF::FillMC(const TObject *particle)
	519	{
	520	//
	521	// fill MC part of the Container
	522	//
e123f993	523	if (!fStepForMCtruth) return;
e123f993	524
6551594b	525	Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
6551594b	526	AliDielectronVarManager::Fill(particle,valuesPair);
8df8e382	527
	528	AliVParticle *d1=0x0;
	529	AliVParticle *d2=0x0;
	530	AliDielectronMC::Instance()->GetDaughters(particle,d1,d2);
	531
	532	valuesPair[AliDielectronVarManager::kThetaHE]=AliDielectronPair::ThetaPhiCM(d1,d2,kTRUE,kTRUE);
	533	valuesPair[AliDielectronVarManager::kPhiHE]=AliDielectronPair::ThetaPhiCM(d1,d2,kTRUE,kFALSE);
	534	valuesPair[AliDielectronVarManager::kThetaCS]=AliDielectronPair::ThetaPhiCM(d1,d2,kFALSE,kTRUE);
	535	valuesPair[AliDielectronVarManager::kPhiCS]=AliDielectronPair::ThetaPhiCM(d1,d2,kFALSE,kFALSE);
6551594b	536
a655b716	537	//TODO: temporary solution, set manually the pair type to 1: unlikesign SE
6551594b	538	valuesPair[AliDielectronVarManager::kPairType]=1;
b2a297fa	539
b2a297fa	540	for (Int_t iVar=0; iVar<fNVars; ++iVar){
b2a297fa	541	Int_t var=fVariables[iVar];
6551594b	542	fValues[iVar]=valuesPair[var];
b2a297fa	543	}
6551594b	544
6551594b	545	if (fNVarsLeg>0){
6551594b	546	Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues];
6551594b	547	Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues];
a655b716	548	if (d1->Pt()>d2->Pt()){
	549	AliDielectronVarManager::Fill(d1,valuesLeg1);
	550	AliDielectronVarManager::Fill(d2,valuesLeg2);
	551	} else {
	552	AliDielectronVarManager::Fill(d2,valuesLeg1);
	553	AliDielectronVarManager::Fill(d1,valuesLeg2);
	554	}
6551594b	555
	556	for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
	557	Int_t var=fVariablesLeg[iVar];
	558	fValues[iVar+fNVars]=valuesLeg1[var];
	559	fValues[iVar+fNVars+fNVarsLeg]=valuesLeg2[var];
	560	}
	561	}
	562
	563	fCfContainer->Fill(fValues,0);
b2a297fa	564	}
b2a297fa	565