ShowRec.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
Bool_t	AddBTToArrayWithCeck (EdbSegP *tryAttachedSegment, TObjArray *GLOBAL_ShowerSegArray)
void	BuildParametrizationsMCInfo_PGun (TString MCInfoFilename)
EdbSegP *	BuildShowerAxis (TObjArray *ShowerSegArray)
Bool_t	CalcConeOrTubeDistanceToInBT (EdbSegP *sa, EdbSegP *InBT, Double_t CylinderRadius, Double_t ConeAngle)
void	CalcEfficencyNumbers (EdbPattern *pat_interim, Int_t MCCheck, Int_t &NBT_Neff, Int_t &NBTMC_Neff, Int_t &NBTMCe_Neff)
void	CalcEffPurOfShower (TObjArray *arr, Int_t &NBT, Int_t &NBTMC, Int_t &NBTallMC, Int_t &NBTeMC, Double_t &purall, Double_t &pure)
void	CalcEffPurOfShower2 (TObjArray *arr, Int_t &NBT, Int_t &NBTMC, Int_t &NBTallMC, Int_t &NBTeMC, Double_t &purall, Double_t &pure, Int_t n1, Int_t n2, Int_t n3)
Double_t	CalcIP (EdbSegP *s, double x, double y, double z)
Double_t	CalcIP (EdbSegP *s, EdbVertex *v)
void	CalcTrackDensity (EdbPattern *pat_interim, Float_t pat_interim_halfsize, Int_t &npat_int, Int_t &npat_total, Int_t &npatN)
EdbVertex *	CalcVertex (TObjArray *segments)
Int_t	Check_ParasetDefinitionFile ()
void	CheckInputParameters ()
void	Create_NN_Alg_Histograms ()
void	CreateOutPutStructures ()
TTree *	CreateTreeBranchShowerTree (Int_t ParaSetNr)
void	Fill2GlobalInBTArray ()
void	FillGlobalInBTArray ()
void	FillOutPutStructures ()
void	FillShowerAxis ()
Bool_t	FindFollowingBTs (EdbSegP *s1, EdbSegP *s2, EdbPVRec *gAli, TObjArray *showersegarray)
Bool_t	FindPrecedingBTs (EdbSegP *s1, EdbSegP *s2, EdbPVRec *gAli, TObjArray *showersegarray)
Bool_t	FindPrecedingBTs_local_gAli (EdbSegP *s1, EdbSegP *s2, EdbPVRec *gAli, TObjArray *showersegarray)
Bool_t	FindPrecedingBTsSingleThetaAngle (EdbSegP *s1, EdbSegP *s2, EdbPVRec *gAli, TObjArray *showersegarray)
Bool_t	FindPrecedingBTsSingleThetaAngleTCDEBUG (EdbSegP *s1, EdbSegP *s2, EdbPVRec *gAli, TObjArray *showersegarray)
void	Get_NN_ALG_MLP (TTree *inputtree, Int_t parasetnr)
Bool_t	GetConeOrTubeDistanceToBTOfShowerArray (EdbSegP *sa, EdbSegP *InBT, TObjArray *showersegarray, Double_t CylinderRadius, Double_t ConeAngle)
Bool_t	GetConeOrTubeDistanceToInBT (EdbSegP *sa, EdbSegP *s, Double_t ConeAngle, Double_t CylinderRadius)
Double_t	GetdeltaRNoPropagation (EdbSegP *s, EdbSegP *stest)
Double_t	GetdeltaRWithPropagation (EdbSegP *s1, EdbSegP *s2)
Double_t	GetdeltaTheta (EdbSegP *s1, EdbSegP *s2)
Double_t	GetdeltaThetaSingleAngles (EdbSegP *s1, EdbSegP *s2)
Double_t	GetdMinDist (EdbSegP *s1, EdbSegP *s2)
Double_t	GetdR (EdbSegP *s1, EdbSegP *s2)
Double_t	GetdT (EdbSegP *s1, EdbSegP *s2)
void	GetEvent_ParasetDefinitionTree (Int_t nr)
Int_t	GetMeansBeforeAndAfter (Float_t &mean_dT, Float_t &mean_dR, EdbPVRec *local_gAli, Int_t patterloop_cnt, EdbSegP *seg, Int_t n_patterns, Int_t BeforeOrAfter)
Double_t	GetMinimumDist (EdbSegP *s1, EdbSegP *s2)
Int_t	GetMinsBeforeAndAfter (Float_t &min_dT, Float_t &min_dR, EdbPVRec *local_gAli, Int_t patterloop_cnt, EdbSegP *seg, Int_t n_patterns, Int_t BeforeOrAfter)
Int_t	GetNSegBeforeAndAfter (EdbPVRec *local_gAli, Int_t patterloop_cnt, EdbSegP *seg, Int_t n_patterns, Int_t BeforeOrAfter)
Double_t	GetSpatialDist (EdbSegP *s1, EdbSegP *s2)
Bool_t	IsSameSegment (EdbSegP *seg1, EdbSegP *seg2)
Bool_t	IsShowerSortedZ (TObjArray *showerarray)
void	Load_NN_ALG_MLP_weights (TMultiLayerPerceptron *mlp, Int_t parasetnr)
void	MakeTracksTree (TTree *treebranch)
Int_t	Open_ParasetDefinitionFile ()
void	PrintShowerObjectArray (TObjArray *segarray)
void	Read_ParasetDefinitionTree ()
void	ReadDefaultValues_CommandLine ()
EdbPVRec *	ReadEdbPVRecObjectFromCurrentDirectory ()
Int_t	Reco_CL_AssignZValueToGroup (Double_t z, Double_t z0, Int_t NGroupedPLATES, Int_t PLATESPerGroup)
void	Reco_CL_BuildGlobalHistogramsOnHeap ()
void	ReconstructShowers (Int_t nr)
void	ReconstructShowers_AG ()
void	ReconstructShowers_BW ()
void	ReconstructShowers_CA ()
void	ReconstructShowers_CL ()
void	ReconstructShowers_CT ()
void	ReconstructShowers_GS ()
void	ReconstructShowers_NN ()
void	ReconstructShowers_OI ()
	void ReconstructShowers_CL() /// Still Missing in the Implementation !!! More...
void	ReconstructShowers_OI2 ()
void	ReconstructShowers_OPENMP ()
void	ReconstructShowers_OPENMP_TEST (EdbSegP *InBT, TObjArray array)
	DEBUG OPENMP TEST!!!!!!! More...
void	ReconstructShowers_RC ()
void	ReconstructShowers_SA ()
void	ReconstructShowers_TC ()
void	RewriteSegmentPIDs (EdbPVRec *gAli)
void	RewriteSegmentPIDs_BGPID_To_SGPID (EdbPVRec *gAli)
void	RewriteSegmentPIDs_SGPID_To_BGPID (EdbPVRec *gAli)
void	SetDefaultValues_CommandLine ()
void	SortShowerZ (TObjArray *showerarray)
void	TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree (TTree *treebranchtree, TObjArray *segarray)
EdbPVRec *	TransformEdbPVRec (EdbPVRec *gAli, EdbSegP *InitiatorBT)
	DEBUG OPENMP TEST!!!!!!! More...
EdbPVRec *	TransformEdbPVRec_BackWard (EdbPVRec *gAli, EdbSegP *InitiatorBT)
EdbPVRec *	TransformEdbPVRec_SA (EdbPVRec *gAli, EdbSegP *InitiatorBT)

Variables
Int_t	cmd_ALI =0
Int_t	cmd_ALTP =2
Int_t	cmd_BGTP =0
Int_t	cmd_BTPA =0
Int_t	cmd_CLEAN =0
Int_t	cmd_CUTTP =0
Int_t	cmd_EXTHETA =0
Int_t	cmd_FILETP =0
Int_t	cmd_FP =1
Int_t	cmd_FZHP =0
Int_t	cmd_GBMC =0
Int_t	cmd_gEDBDEBUGLEVEL =2
char *	cmd_lnkdef_name = "lnk.def"
Int_t	cmd_LP =30
Int_t	cmd_LT =0
Int_t	cmd_MC =0
Int_t	cmd_MCFL =0
Int_t	cmd_MCMIX =0
Int_t	cmd_MP =1
Int_t	cmd_NP =30
Int_t	cmd_OUTPUTLEVEL =1
Int_t	cmd_PADI =0
Int_t	cmd_PAEND =0
Int_t	cmd_PASTART =0
Int_t	cmd_STOPLEVEL =0
Int_t	cmd_vtx =0
Double_t	CUT_PARAMETER [10]
TFile *	f_GSNN
TFile *	FILE_ParaSetDefinitions
TFile *	FILE_ShowRecEff
TFile *	FILE_ShowRecHistos
TFile *	FILE_ShowShower
TFile *	FILE_ShowTracks
Int_t	gEDBDEBUGLEVEL =2
Double_t	GLOBAL_effall
Double_t	GLOBAL_effe
Double_t	GLOBAL_EvtBT_E
Double_t	GLOBAL_EvtBT_EArray [99999]
Int_t	GLOBAL_EvtBT_Flag
Int_t	GLOBAL_EvtBT_FlagArray [99999]
Int_t	GLOBAL_EvtBT_MC
Int_t	GLOBAL_EvtBT_MCArray [99999]
Double_t	GLOBAL_EvtBT_TanTheta
Double_t	GLOBAL_EvtBT_TanThetaArray [99999]
Int_t	GLOBAL_EvtBT_ZArray [99999]
EdbPVRec *	GLOBAL_gAli
Double_t	GLOBAL_InBT_E
Int_t	GLOBAL_InBT_Flag
Int_t	GLOBAL_InBT_MC
Double_t	GLOBAL_InBT_TanTheta
TObjArray *	GLOBAL_InBTArray
Int_t	GLOBAL_InBTArrayEntries
Int_t	GLOBAL_INBTSHOWERNR
Bool_t	GLOBAL_IsBrickTreePGunInfo =kFALSE
Int_t	GLOBAL_NBT
Int_t	GLOBAL_NBTallMC
Int_t	GLOBAL_NBTeMC
Int_t	GLOBAL_NBTMC
Int_t	GLOBAL_PARASETNR
Double_t	GLOBAL_purall
Double_t	GLOBAL_pure
TObjArray *	GLOBAL_ShowerSegArray
Double_t	GLOBAL_trckdens
TObjArray *	GLOBAL_VtxArray
Float_t	GLOBAL_VtxArrayX [99999]
Float_t	GLOBAL_VtxArrayY [99999]
Float_t	GLOBAL_VtxArrayZ [99999]
TH1F *	h_GSNN_var00
TH1F *	h_GSNN_var01
TH1F *	h_GSNN_var02
TH1F *	h_GSNN_var03
TH1F *	h_GSNN_var04
TH1F *	h_GSNN_var05
TH1F *	h_GSNN_var06
TH2F *	Hist2DimBGAndSimOneEventAllPlates
TH2F *	Hist2DimBGAndSimOneEventOneGroupedPlate [50]
TH2F *	Hist2DimOnlyBGAllPlates
TH2F *	Hist2DimOnlyBGOneGroupedPlate [50]
TH2F *	Hist2DimOnlySimOneEventAllPlates
TH2F *	Hist2DimOnlySimOneEventOneGroupedPlate [50]
TH3F *	Hist3DimOnlyBG
TH3F *	Hist3DimRecoEvent_gAli
TH3F *	Hist3DimRecoEvent_gAli_Dummy
TH2F *	Hist_NBT_InBTE
TH2F *	Hist_NBTallMC_purall
TH2F *	Hist_NBTeMC_InBTE
TH2F *	Hist_NBTeMC_NBT
TH2F *	Hist_NBTeMC_NBTMC
TH2F *	Hist_NBTeMC_pure
TH2F *	Hist_purall_InBTE
TH2F *	Hist_pure_InBTE
Float_t	local_halfpatternsize =1250
TProfile *	NBT_InBTE
TProfile *	NBTallMC_purall
TProfile *	NBTeMC_InBTE
TProfile *	NBTeMC_NBT
TProfile *	NBTeMC_NBTMC
TProfile *	NBTeMC_pure
TProfile *	purall_InBTE
TProfile *	pure_InBTE
Float_t	shower_axis_txb
Float_t	shower_axis_tyb
Float_t	shower_axis_xb
Float_t	shower_axis_yb
Float_t	shower_axis_zb
Float_t	shower_chi2btkb [5000]
Float_t	shower_deltarb [5000]
Float_t	shower_deltasigmathetab [58]
Float_t	shower_deltathetab [5000]
Float_t	shower_deltaxb [5000]
Float_t	shower_deltayb [5000]
Float_t	shower_energy_shot_particle
Int_t	shower_filetype
Int_t	shower_idb [5000]
Int_t	shower_isizeb
Int_t	shower_nfilmb [5000]
Int_t	shower_ngrainb [5000]
Int_t	shower_ntrace1simub [5000]
Int_t	shower_ntrace2simub [5000]
Float_t	shower_ntrace3simub [5000]
Int_t	shower_ntrace4simub [5000]
Int_t	shower_number_eventb
Int_t	shower_numberofholes =0
Int_t	shower_numberofholesconseq =0
Int_t	shower_numberofilms
Int_t	shower_plateb [5000]
Float_t	shower_purb
Int_t	shower_showerID
Int_t	shower_sizeb
Int_t	shower_sizeb15
Int_t	shower_sizeb20
Int_t	shower_sizeb30
Float_t	shower_tagprimary [5000]
Float_t	shower_trackdensb
Float_t	shower_txb [5000]
Float_t	shower_tyb [5000]
Float_t	shower_xb [5000]
Float_t	shower_yb [5000]
Float_t	shower_zb [5000]
TSpectrum2 *	spectrum [50]
TSpectrum2 *	spectrum2dim
TH2F *	spectrum_interim
ofstream	STREAM_ShowRecEff
TString	STREAM_ShowRecEffName
ofstream	STREAM_ShowShower
TString	STRING_ShowShowerName
TString	STRING_ShowTracksName
TTree *	t_GSNN
TMultiLayerPerceptron *	TMlpANN
TTree *	TREE_ParaSetDefinitions
TTree *	TREE_ShowRecEff
TTree *	TREE_ShowShower
Float_t	value_GSNN_var00
Float_t	value_GSNN_var01
Float_t	value_GSNN_var02
Float_t	value_GSNN_var03
Float_t	value_GSNN_var04
Float_t	value_GSNN_var05
Float_t	value_GSNN_var06
Float_t	value_GSNN_varInput
TH1F *	var_NN__ALL__dR_InBT_To_TestBT
TH1F *	var_NN__ALL__dR_TestBT_To_InBT
TH1F *	var_NN__ALL__dT_InBT_To_TestBT
TH1F *	var_NN__ALL__mean_dR_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__mean_dR_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__mean_dR_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__mean_dR_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__mean_dR_TestBT_ToSamePlate
TH1F *	var_NN__ALL__mean_dT_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__mean_dT_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__mean_dT_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__mean_dT_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__mean_dT_TestBT_ToSamePlate
TH1F *	var_NN__ALL__min_dR_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__min_dR_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__min_dR_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__min_dR_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__min_dR_TestBT_ToSamePlate
TH1F *	var_NN__ALL__min_dT_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__min_dT_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__min_dT_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__min_dT_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__min_dT_TestBT_ToSamePlate
TH1F *	var_NN__ALL__nseg_TestBT_To2AfterPlate
TH1F *	var_NN__ALL__nseg_TestBT_To2BeforePlate
TH1F *	var_NN__ALL__nseg_TestBT_ToAfterPlate
TH1F *	var_NN__ALL__nseg_TestBT_ToBeforePlate
TH1F *	var_NN__ALL__nseg_TestBT_ToSamePlate
TH1F *	var_NN__ALL__SpatialDist_TestBT_To_InBT
TH1F *	var_NN__ALL__zDiff_TestBT_To_InBT
TH1F *	var_NN__BG__dR_InBT_To_TestBT
TH1F *	var_NN__BG__dR_TestBT_To_InBT
TH1F *	var_NN__BG__dT_InBT_To_TestBT
TH1F *	var_NN__BG__mean_dR_TestBT_To2AfterPlate
TH1F *	var_NN__BG__mean_dR_TestBT_To2BeforePlate
TH1F *	var_NN__BG__mean_dR_TestBT_ToAfterPlate
TH1F *	var_NN__BG__mean_dR_TestBT_ToBeforePlate
TH1F *	var_NN__BG__mean_dR_TestBT_ToSamePlate
TH1F *	var_NN__BG__mean_dT_TestBT_To2AfterPlate
TH1F *	var_NN__BG__mean_dT_TestBT_To2BeforePlate
TH1F *	var_NN__BG__mean_dT_TestBT_ToAfterPlate
TH1F *	var_NN__BG__mean_dT_TestBT_ToBeforePlate
TH1F *	var_NN__BG__mean_dT_TestBT_ToSamePlate
TH1F *	var_NN__BG__min_dR_TestBT_To2AfterPlate
TH1F *	var_NN__BG__min_dR_TestBT_To2BeforePlate
TH1F *	var_NN__BG__min_dR_TestBT_ToAfterPlate
TH1F *	var_NN__BG__min_dR_TestBT_ToBeforePlate
TH1F *	var_NN__BG__min_dR_TestBT_ToSamePlate
TH1F *	var_NN__BG__min_dT_TestBT_To2AfterPlate
TH1F *	var_NN__BG__min_dT_TestBT_To2BeforePlate
TH1F *	var_NN__BG__min_dT_TestBT_ToAfterPlate
TH1F *	var_NN__BG__min_dT_TestBT_ToBeforePlate
TH1F *	var_NN__BG__min_dT_TestBT_ToSamePlate
TH1F *	var_NN__BG__nseg_TestBT_To2AfterPlate
TH1F *	var_NN__BG__nseg_TestBT_To2BeforePlate
TH1F *	var_NN__BG__nseg_TestBT_ToAfterPlate
TH1F *	var_NN__BG__nseg_TestBT_ToBeforePlate
TH1F *	var_NN__BG__nseg_TestBT_ToSamePlate
TH1F *	var_NN__BG__SpatialDist_TestBT_To_InBT
TH1F *	var_NN__BG__zDiff_TestBT_To_InBT
TH1F *	var_NN__SG__dR_InBT_To_TestBT
TH1F *	var_NN__SG__dR_TestBT_To_InBT
TH1F *	var_NN__SG__dT_InBT_To_TestBT
TH1F *	var_NN__SG__mean_dR_TestBT_To2AfterPlate
TH1F *	var_NN__SG__mean_dR_TestBT_To2BeforePlate
TH1F *	var_NN__SG__mean_dR_TestBT_ToAfterPlate
TH1F *	var_NN__SG__mean_dR_TestBT_ToBeforePlate
TH1F *	var_NN__SG__mean_dR_TestBT_ToSamePlate
TH1F *	var_NN__SG__mean_dT_TestBT_To2AfterPlate
TH1F *	var_NN__SG__mean_dT_TestBT_To2BeforePlate
TH1F *	var_NN__SG__mean_dT_TestBT_ToAfterPlate
TH1F *	var_NN__SG__mean_dT_TestBT_ToBeforePlate
TH1F *	var_NN__SG__mean_dT_TestBT_ToSamePlate
TH1F *	var_NN__SG__min_dR_TestBT_To2AfterPlate
TH1F *	var_NN__SG__min_dR_TestBT_To2BeforePlate
TH1F *	var_NN__SG__min_dR_TestBT_ToAfterPlate
TH1F *	var_NN__SG__min_dR_TestBT_ToBeforePlate
TH1F *	var_NN__SG__min_dR_TestBT_ToSamePlate
TH1F *	var_NN__SG__min_dT_TestBT_To2AfterPlate
TH1F *	var_NN__SG__min_dT_TestBT_To2BeforePlate
TH1F *	var_NN__SG__min_dT_TestBT_ToAfterPlate
TH1F *	var_NN__SG__min_dT_TestBT_ToBeforePlate
TH1F *	var_NN__SG__min_dT_TestBT_ToSamePlate
TH1F *	var_NN__SG__nseg_TestBT_To2AfterPlate
TH1F *	var_NN__SG__nseg_TestBT_To2BeforePlate
TH1F *	var_NN__SG__nseg_TestBT_ToAfterPlate
TH1F *	var_NN__SG__nseg_TestBT_ToBeforePlate
TH1F *	var_NN__SG__nseg_TestBT_ToSamePlate
TH1F *	var_NN__SG__SpatialDist_TestBT_To_InBT
TH1F *	var_NN__SG__zDiff_TestBT_To_InBT
Bool_t	var_NN_DoRUN =kTRUE
Bool_t	var_NN_DoTrain =kFALSE

Function Documentation

AddBTToArrayWithCeck()

Bool_t AddBTToArrayWithCeck	(	EdbSegP *	tryAttachedSegment,
		TObjArray *	GLOBAL_ShowerSegArray
	)

void ReconstructShowers_CL() /// Still Missing in the Implementation !!! BUT it is there now in ReconstructShowers_CL() function. TO CHECK IF THE ALGORITHM IS WORKING (NO MATTER THE BAD EFFICIENCY)

{
    // We add by comparison with X,Y,TX,TY values, since this seems to be more failsafe
    // than adding by adresses.
    // This function returns   kTRUE   if  BT is already in the shower array
    // This function returns   kFALSE  if  BT is not yet in the shower array
 
    int nent=GLOBAL_ShowerSegArray->GetEntries();
    EdbSegP* ComparingSegment;
 
 
    if (gEDBDEBUGLEVEL>3) cout << "AddBTToArrayWithCeck()   Check: "<< tryAttachedSegment << " with all "<< nent << " entries of GLOBAL_ShowerSegArray "<< endl;
 
    Bool_t IsContained=kFALSE;
 
    for (int i=0; i<nent; ++i) {
        ComparingSegment=(EdbSegP*)GLOBAL_ShowerSegArray->At(i);
        if (TMath::Abs(tryAttachedSegment->X()-ComparingSegment->X())>0.1) continue;
        if (TMath::Abs(tryAttachedSegment->Y()-ComparingSegment->Y())>0.1) continue;
 
        if (TMath::Abs(tryAttachedSegment->TX()-ComparingSegment->TX())>0.01) continue;
        if (TMath::Abs(tryAttachedSegment->TY()-ComparingSegment->TY())>0.01) continue;
 
        IsContained=kTRUE;
    }
 
 
    if (gEDBDEBUGLEVEL>3) cout << "AddBTToArrayWithCeck DO WE ADD THIS BT ?? "<< !IsContained << endl;
 
    if (!IsContained) {
        GLOBAL_ShowerSegArray->Add(tryAttachedSegment);
    }
 
    return !IsContained;
}

BuildParametrizationsMCInfo_PGun()

void BuildParametrizationsMCInfo_PGun

(

TString

MCInfoFilename

)

                                                              {
    //Declare Tree Variables
    Int_t MCEvt, PDGId;
    Float_t energy, tantheta,dirx,diry,dirz,vtxposx,vtxposy,vtxposz;
    Float_t TX,TY,Y,X,Z;
 
 
    // Read Tree with File:
    TTree* PGunTree = new TTree();
    PGunTree->ReadFile(MCInfoFilename,"MCEvt/I:energy/F:tantheta/F:dirx/F:diry/F:dirz/F:vtxposx/F:vtxposy/F:vtxposz/F:TX/F:TY/F:X/F:Y/F:Z/F:PDGId/I");
    PGunTree->SetBranchAddress("MCEvt",&MCEvt);
    PGunTree->SetBranchAddress("PDGId",&PDGId);
    PGunTree->SetBranchAddress("energy",&energy);
    PGunTree->SetBranchAddress("tantheta",&tantheta);
    PGunTree->SetBranchAddress("dirx",&dirx);
    PGunTree->SetBranchAddress("diry",&diry);
    PGunTree->SetBranchAddress("dirz",&dirz);
    PGunTree->SetBranchAddress("vtxposx",&vtxposx);
    PGunTree->SetBranchAddress("vtxposy",&vtxposy);
    PGunTree->SetBranchAddress("vtxposz",&vtxposz);
    PGunTree->SetBranchAddress("TX",&TX);
    PGunTree->SetBranchAddress("TY",&TY);
    PGunTree->SetBranchAddress("X",&X);
    PGunTree->SetBranchAddress("Z",&Z);
    PGunTree->SetBranchAddress("Y",&Y);
    if (gEDBDEBUGLEVEL>2) PGunTree->Print();
 
 
 
 
    if (cmd_GBMC>0) PGunTree->Show(cmd_GBMC);
    cout << "PGunTree->GetEntries();    " <<  PGunTree->GetEntries() <<  endl;
 
    // If the PGunTree is not filled, this can be a hint that the
    // MCInfoFilename might not be there. This is important for alorithms that
    // rely on Vertex Informations, like the _GS() alg.
    if (PGunTree->GetEntries()==0) {
        cout << "ATTENTION!   PGunTree->GetEntries()==0" << endl;
        cout << "Bool_t             GLOBAL_IsBrickTreePGunInfo=kFALSE;" << endl;
        GLOBAL_IsBrickTreePGunInfo=kFALSE;
    }
    else {
        GLOBAL_IsBrickTreePGunInfo=kTRUE;
    }
 
    if (!GLOBAL_VtxArray) GLOBAL_VtxArray=new TObjArray(69999);
    GLOBAL_VtxArrayX[0]=0;
    GLOBAL_VtxArrayZ[0]=0;
    GLOBAL_VtxArrayY[0]=0;
 
    //------------------
    Int_t PGunTreeEntry_MCEvt_Correspondance[69999]; // PGunTreeEntry_MCEvt_Correspondance[0]=TreeEntry(0)->MC()
    for (Int_t i=0; i<PGunTree->GetEntries(); ++i) {
        PGunTree->GetEntry(i);
        PGunTreeEntry_MCEvt_Correspondance[MCEvt]=i;
        EdbVertex* vtx=new EdbVertex();
        vtx->SetXYZ(vtxposx*1000,vtxposy*1000,(vtxposz+40.0)*1000);
        vtx->SetMC(MCEvt);
        // vtx->Print(); // Gives Crash!
        GLOBAL_VtxArray->Add(vtx);
        GLOBAL_VtxArrayX[MCEvt]=vtxposx*1000;
        GLOBAL_VtxArrayY[MCEvt]=vtxposy*1000;
        GLOBAL_VtxArrayZ[MCEvt]=(vtxposz+40.0)*1000;
//                              vtx->Print();
//              cout << vtx->X() << endl;
//              cout << vtx->Y() << endl;
//              cout << vtx->Z() << endl;
// gSystem->Exit(1);
        GLOBAL_EvtBT_EArray[MCEvt]=energy;
        GLOBAL_EvtBT_TanThetaArray[MCEvt]=tantheta;
        GLOBAL_EvtBT_FlagArray[MCEvt]=0;
        GLOBAL_EvtBT_MCArray[MCEvt]=MCEvt;
        GLOBAL_EvtBT_ZArray[MCEvt]=(vtxposz+40.0)*1000;
    }
    //------------------
 
    cout << "BuildParametrizationsMCInfo_PGun.... done." << endl;
    return;
}

BuildShowerAxis()

EdbSegP* BuildShowerAxis

(

TObjArray *

ShowerSegArray

)

MNORMINERUNG !!!! STILL NOT AN IMPROVEMENT FOR GAMMAS.....

Differene NOW FOR DEBUG TESTS !!!!

MNORMINERUNG !!!! STILL NOT AN IMPROVEMENT FOR GAMMAS.....

Differene NOW FOR DEBUG TESTS !!!!

{
    Int_t eNBT= ShowerSegArray->GetEntries();
    if (eNBT==0) return NULL;
    if (eNBT==1) return (EdbSegP*)ShowerSegArray->At(0);
    Double_t eNBT_float=(Double_t)eNBT;
//      cout << "eNBT= " << eNBT << "  eNBT_float= " << eNBT_float << endl;
 
    // Code taken from EdbMath::LFIT3 to fit line to a collection of points in spce!
    //int EdbMath::LFIT3( float *X, float *Y, float *Z, float *W, int L,
    //float &X0, float &Y0, float &Z0, float &TX, float &TY, float &EX, float &EY )
    // Linar fit in 3-d case (microtrack-like)
    // Input: X,Y,Z - coords, W -weight - arrays of the lengh >=L
    // Note that X,Y,Z modified by function
    // Output: X0,Y0,Z0 - center of gravity of segment
    // TX,TY : tangents in respect to Z axis
 
    Float_t X0,Y0,Z0;
    Float_t TX,TY;
    Float_t EX,EY;
    // Float_t x[eNBT]; Float_t z[eNBT];    Float_t y[eNBT];    Float_t W[eNBT];
    // Compiled with -pedantic -Wall -W -Wstrict-prototypes this gives error message: Fehler: ISO-C++ verbietet Feld »x« variabler Länge
    // So we take it as fixed length:
    // As before we take the global maximum of 5k BT /shower.
    Float_t x[5000];
    Float_t z[5000];
    Float_t y[5000];
    Float_t W[5000];
 
 
    // SUM UP TANGES VALUES OF ALL BTS SO FAR TO GET tx and TY of SHOWERCENTER ???
    Float_t sumX=0;
    Float_t sumY=0;
    Float_t sumTX=0;
    Float_t sumTY=0;
    Float_t sumW=0;
//
    // The weighting of the segments is a crucial point here, since it influences
    // the fitting to the shower axis!
    int eNBTMAX=TMath::Min(5000,eNBT);
    for (int i=0; i<eNBTMAX; i++) {
        EdbSegP*    TestBT = (EdbSegP*)ShowerSegArray->At(i);
        x[i]=TestBT->X();
        y[i]=TestBT->Y();
        z[i]=TestBT->Z();
        // Choose weighting to be one!
        W[i]=1;
        W[i]=1.0/(TMath::Abs(z[i]-z[0])/1300.0*TMath::Abs(z[i]-z[0])/1300.0+1);
        //      W[i]=1.0/TMath::Sqrt((TMath::Abs(z[i]-z[0])/1300.0*TMath::Abs(z[i]-z[0])/1300.0+1));
        if (TMath::Abs(z[i]-z[0])/1300.0>4) W[i]=0;
        // chose this,....could be that this will  lead to something different results....
        sumX+=W[i]*TestBT->X();
        sumY+=W[i]*TestBT->Y();
        sumTX+=W[i]*TestBT->TX();
        sumTY+=W[i]*TestBT->TY();
        sumW+=W[i];
    }
    //cout << " Set all others to zero...." << endl;
    if  (eNBT<5000) {
        for (int i=eNBT; i<5000; i++) {
            W[i]=0;
            x[i]=0;
            y[i]=0;
            z[i]=0;
        }
    }
 
 
    //cout << "BuildShowerAxis   Invoke fit function:" << endl;
    // Invoke fit function:
    EdbMath::LFIT3( x,y,z,W,eNBTMAX,X0,Y0,Z0,TX,TY,EX,EY);
 
    //cout <<"AfterLinefit: x=" << x << " y=" << y << " z=" << z << " W=" << W << " eNBTMAX=" << eNBTMAX << " X0=" << X0 << " Y0=" << Y0 << " Z0=" << Z0 << " TX=" << TX << " TY= " << TY << endl;
 
    sumTX=sumTX/sumW;
    sumTY=sumTY/sumW;
    sumX=sumTX/sumW;
    sumY=sumTY/sumW;
 
    //==C== In few cases "nan" can happen, then we put val to -1;
    if (TMath::IsNaN(X0)) {
        //cout << "EdbShowerP::BuildShowerAxis   WARNING! FIT DID NOT CONVVERGE, RETURN FIRST SEGMENT! " << endl;
        EdbSegP* seg0=(EdbSegP*)ShowerSegArray->At(0);
        EdbSegP* eShowerAxisCenterGravityBT = new EdbSegP(0,seg0->X(),seg0->Y(),seg0->TX(),seg0->TY(),0,0);
        eShowerAxisCenterGravityBT -> SetZ(((EdbSegP*)ShowerSegArray->At(0))->Z());
        //eShowerAxisCenterGravityBT->PrintNice();
        return eShowerAxisCenterGravityBT;
    }
 
    //cout << "EdbShowerP::BuildShowerAxis   Axis  X0,Y0,Z0, TX, TY " <<  X0 << " " << Y0 << " " << Z0 << " " << TX << " " << TY << " " << endl;
    //cout << "sumTX=  " << sumTX << "   sumTY=  " << sumTY <<  "   sumW=  " << sumW << endl;
 
    EdbSegP* eShowerAxisCenterGravityBT = 0;
    if (!eShowerAxisCenterGravityBT) eShowerAxisCenterGravityBT = new EdbSegP(-1,X0,Y0,sumTX,sumTY,0,0); // with linefit
//     if (!eShowerAxisCenterGravityBT) eShowerAxisCenterGravityBT = new EdbSegP(-1,sumX,sumY,sumTX,sumTY,0,0); // without linefit
    eShowerAxisCenterGravityBT -> SetZ(((EdbSegP*)ShowerSegArray->At(0))->Z());
 
 
    //      Bool_t UseOnlyFirstBT=kTRUE;
    Bool_t UseOnlyFirstBT=kFALSE;
    if (UseOnlyFirstBT) {
        cout << "Attention: UseOnlyFirstBT"<< endl;
        eShowerAxisCenterGravityBT -> SetX(((EdbSegP*)ShowerSegArray->At(0))->X());
        eShowerAxisCenterGravityBT -> SetY(((EdbSegP*)ShowerSegArray->At(0))->Y());
        eShowerAxisCenterGravityBT -> SetZ(((EdbSegP*)ShowerSegArray->At(0))->Z());
        eShowerAxisCenterGravityBT -> SetTX(((EdbSegP*)ShowerSegArray->At(0))->TX());
        eShowerAxisCenterGravityBT -> SetTY(((EdbSegP*)ShowerSegArray->At(0))->TY());
    }
 
    //eShowerAxisCenterGravityBT->Print();
    return eShowerAxisCenterGravityBT;
}

CalcConeOrTubeDistanceToInBT()

Bool_t CalcConeOrTubeDistanceToInBT	(	EdbSegP *	sa,
		EdbSegP *	InBT,
		Double_t	CylinderRadius,
		Double_t	ConeAngle
	)

Outside if angle greater than ConeAngle (to be fulfilled for Cone and Tube in both cases)

if angle smaller than ConeAngle, then you can differ between Tuberadius and CylinderRadius

Outside if angle greater than ConeAngle (to be fulfilled for Cone and Tube in both cases)

if angle smaller than ConeAngle, then you can differ between Tuberadius and CylinderRadius

{
    Log(4,"ShowRec.cpp", "--- Bool_t CalcConeOrTubeDistanceToInBT() ---");
 
    TVector3 x1(InBT->X(),InBT->Y(),InBT->Z());
    TVector3 x2(sa->X(),sa->Y(),sa->Z());
    TVector3 direction_x1(InBT->TX()*1300,InBT->TY()*1300,1300);
    TVector3 direction_x2(sa->TX()*1300,sa->TY()*1300,1300);
    TVector3 u1=x2-x1;
 
    Double_t direction_x1_norm= direction_x1.Mag();
    Double_t cosangle=  (direction_x1*u1)/(u1.Mag()*direction_x1_norm);
    Double_t angle = TMath::ACos(cosangle);
    // NO THIS IS NOT THE CONE ANGLE!!
 
    TVector3 direction_1(InBT->TX()*1300,InBT->TY()*1300,1300);
    TVector3 direction_2(sa->TX()*1300,sa->TY()*1300,1300);
 
    angle=u1.Angle(direction_x1);
 
 
    // For the case where the two basetracks have same z position
    // the angle is about 90 degree so it makes no sense to calculate it...
    // therefore we set it artificially to zero:
    if (TMath::Abs(InBT->Z()-sa->Z())<5.0 ) {
        angle=0.0;
        //if (gEDBDEBUGLEVEL>3) //cout << "same z position, set angle artificially to zero" << endl;
    }
 
 
 
    // If this InBT is in z position AFTER the testBT, the cone goes in the other direction and therefore, we have
    // to mirror the angle by 180 degree:
    if (angle>TMath::Pi()/2.0) {
        angle=TMath::Abs(TMath::Pi()-angle);
        //cout << "reverse angle: " << angle << endl;
    }
 
    if (angle>ConeAngle) {
        return kFALSE;
    }
 
    Double_t TubeDistance = 1.0/direction_x1_norm  *  ( (x2-x1).Cross(direction_x1) ).Mag();
    //  cout << "CylinderRadius= " <<  CylinderRadius << "  TubeDistance= " << TubeDistance << endl;
    if (TubeDistance>CylinderRadius) {
        return kFALSE;
    }
 
 
 
    //cout << "--- Bool_t CalcConeOrTubeDistanceToInBT() ---"<<endl;
    //InBT->PrintNice();
    //sa->PrintNice();
    //cout << "angle= " <<  angle << "  ConeAngle= " << ConeAngle << endl;
    //cout << "CylinderRadius= " <<  CylinderRadius << "  TubeDistance= " << TubeDistance << endl;
 
    return kTRUE;
}

CalcEfficencyNumbers()

void CalcEfficencyNumbers	(	EdbPattern *	pat_interim,
		Int_t	MCCheck,
		Int_t &	NBT_Neff,
		Int_t &	NBTMC_Neff,
		Int_t &	NBTMCe_Neff
	)

{
    if (gEDBDEBUGLEVEL>3) cout << "-------------void CalcEfficencyNumbers()"<<endl;
    Int_t npat_int=pat_interim->GetN();
    if (npat_int<=0) return;
 
    for (int i=0; i<pat_interim->N(); ++i) {
        EdbSegP* seg=(EdbSegP* )pat_interim->GetSegment(i);
        if (seg->MCEvt()<0||seg->MCEvt()==MCCheck) ++NBT_Neff;
        if (seg->MCEvt()==MCCheck) ++NBTMC_Neff;
        if (seg->MCEvt()==MCCheck&&TMath::Abs(seg->Flag())==11) ++NBTMCe_Neff;
    }
    if (gEDBDEBUGLEVEL>3) {
        cout << "npat_int = " << npat_int << endl;
        cout << "NBT_Neff = " << NBT_Neff << endl;
        cout << "NBTMC_Neff = " << NBTMC_Neff << endl;
        cout << "NBTMCe_Neff = " << NBTMCe_Neff << endl;
    }
    return;
}

CalcEffPurOfShower()

void CalcEffPurOfShower	(	TObjArray *	arr,
		Int_t &	NBT,
		Int_t &	NBTMC,
		Int_t &	NBTallMC,
		Int_t &	NBTeMC,
		Double_t &	purall,
		Double_t &	pure
	)

{
    Log(3, "ShowRec.cpp", "--- void CalcEffPurOfShower() ---");
    EdbSegP* seg;
    for (int i=0; i<arr->GetEntries(); ++i) {
        seg=(EdbSegP*)arr->At(i);
        ++NBT;
        if (seg->MCEvt()>0) {
            ++NBTMC;     //NBTMC is kept for backward compability
            ++NBTallMC;
        }
        if (seg->MCEvt()>0 && TMath::Abs(seg->Flag())==11) {
            ++NBTeMC;
        }
    }
 
    purall=-1;
    pure=-1;
    if (NBT!=0) purall=(Double_t)NBTallMC/(Double_t)NBT;
    if (NBT!=0) pure=(Double_t)NBTeMC/(Double_t)NBT;
 
    if (gEDBDEBUGLEVEL>2) {
        cout << "CalcEffPurOfShower---------------- NBT,NBTallMC,NBTeMC,purall,pure=  "<< NBT <<" " <<  NBTallMC <<" " << NBTeMC <<" " << purall <<" " << pure <<" " <<endl;
    }
 
    GLOBAL_NBT=NBT;
    GLOBAL_NBTallMC=NBTallMC;
    GLOBAL_NBTMC=NBTallMC; // kept for backward compability
    GLOBAL_NBTeMC=NBTeMC;
    GLOBAL_purall=purall;
    GLOBAL_pure=pure;
    return;
}

CalcEffPurOfShower2()

void CalcEffPurOfShower2	(	TObjArray *	arr,
		Int_t &	NBT,
		Int_t &	NBTMC,
		Int_t &	NBTallMC,
		Int_t &	NBTeMC,
		Double_t &	purall,
		Double_t &	pure,
		Int_t	n1,
		Int_t	n2,
		Int_t	n3
	)

{
    Log(3, "ShowRec.cpp", "--- void CalcEffPurOfShower2() ---");
    EdbSegP* seg;
 
    for (int i=0; i<arr->GetEntries(); ++i) {
        seg=(EdbSegP*)arr->At(i);
        ++NBT;
        if (seg->MCEvt()>0) {
            ++NBTMC;     //NBTMC is kept for backward compability
            ++NBTallMC;
        }
        if (seg->MCEvt()>0 && TMath::Abs(seg->Flag())==11) {
            ++NBTeMC;
        }
    }
 
    purall=-1;
    pure=-1;
    if (NBT!=0) purall=(Double_t)NBTallMC/(Double_t)NBT;
    if (NBT!=0) pure=(Double_t)NBTeMC/(Double_t)NBT;
 
    // eff_all = NBTMC_SHOWER/NBTMC_VOLUME
    // eff_e = NBTMCe_SHOWER/NBTMCe_VOLUME
 
    Double_t effall=0;
    if (NBTMC_Neff!=0) effall = (Double_t)NBTMC/(Double_t)NBTMC_Neff;
    Double_t effe=0;
    if (NBTMC_Neff!=0) effe  = (Double_t)NBTeMC/(Double_t)NBTMCe_Neff;
 
    if (gEDBDEBUGLEVEL>2) {
        cout << "CalcEffPurOfShower2---------------- NBT,NBTallMC,NBTeMC,purall,pure, effall, effe=  "<< NBT <<" " <<  NBTallMC;
        cout <<" " << NBTeMC <<" " << purall <<" " << pure <<" " << effall <<" " << effe <<" " << endl;
    }
 
    GLOBAL_NBT=NBT;
    GLOBAL_NBTallMC=NBTallMC;
    GLOBAL_NBTMC=NBTallMC; // kept for backward compability
    GLOBAL_NBTeMC=NBTeMC;
    GLOBAL_purall=purall;
    GLOBAL_pure=pure;
    GLOBAL_effall=effall;
    GLOBAL_effe=effe;
 
    Log(3, "ShowRec.cpp", "--- void CalcEffPurOfShower2() done.");
    return;
}

CalcIP() [1/2]

Double_t CalcIP	(	EdbSegP *	s,
		double	x,
		double	y,
		double	z
	)

                                                          {
    // Calculate IP between a given segment and a given x,y,z.
    // return the IP value.
    double ax = s->TX();
    double ay = s->TY();
    double bx = s->X()-ax*s->Z();
    double by = s->Y()-ay*s->Z();
    double a;
    double r;
    double xx,yy,zz;
    a = (ax*(x-bx)+ay*(y-by)+1.*(z-0.))/(ax*ax+ay*ay+1.);
    xx = bx +ax*a;
    yy = by +ay*a;
    zz = 0. +1.*a;
    r = sqrt((xx-x)*(xx-x)+(yy-y)*(yy-y)+(zz-z)*(zz-z));
    return r;
}

CalcIP() [2/2]

Double_t CalcIP	(	EdbSegP *	s,
		EdbVertex *	v
	)

                                          {
    // calculate IP for the selected tracks wrt the given vertex.
    // if the vertex is not given, use the selected vertex.
    if (NULL==v) {
        printf("select a vertex!\n");
        return 0;
    }
    if (gEDBDEBUGLEVEL>3) printf(" /// Calc IP w.r.t. Vertex %d %8.1lf %8.1lf %8.1lf (red vertex) ///\n",v->ID(), v->X(),v->Y(),v->Z() );
    double r = CalcIP(s,v->X(),v->Y(),v->Z());
    return r;
}

CalcTrackDensity()

void CalcTrackDensity	(	EdbPattern *	pat_interim,
		Float_t	pat_interim_halfsize,
		Int_t &	npat_int,
		Int_t &	npat_total,
		Int_t &	npatN
	)

{
    if (gEDBDEBUGLEVEL>3) cout << "-------------void CalcTrackDensity(&pat_interim,pat_interim_halfsize,&npat_int,&npat_total)"<<endl;
    npat_int=pat_interim->GetN();
    if (npat_int<=0) return;
    npat_total+=npat_int;
    ++npatN;
    if (npatN>0) shower_trackdensb=(Float_t)npat_total/(Float_t)npatN/local_halfpatternsize/local_halfpatternsize/4.0*1000.0*1000.0; // BT/mm2  // contains SG and BG tracks!
 
    if (gEDBDEBUGLEVEL>3) {
        cout << "pat_interim->Z() = " << pat_interim->Z() << endl;
        cout << "pat_interim->GetN() = " << pat_interim->GetN() << endl;
        cout << "npat_int = " << npat_int << endl;
        cout << "npat_total = " << npat_total << endl;
        cout << "npatN = " << npatN << endl;
        cout << "shower_trackdensb = " << shower_trackdensb << endl;
    }
    return;
}

CalcVertex()

EdbVertex* CalcVertex

(

TObjArray *

segments

)

                                           {
 
    // Exactly same implementation as in EdbEDAUtil.C
    // but I do not want to link in hardcoded all eda libraries.
    // calc vertex point with given segments. just topological calculation.
    // VTA is currently not set.
    // in case of Single-stop. make a vertex 650 micron upstream ob base.
 
 
    double xx,yy,zz,Det,Ax,Ay,Az,Bx,By,Bz,Cx,Cy,Cz,Dx,Dy,Dz;
    Ax=0.;
    Ay=0.;
    Az=0.;
    Bx=0.;
    By=0.;
    Bz=0.;
    Cx=0.;
    Cy=0.;
    Cz=0.;
    Dx=0.;
    Dy=0.;
    Dz=0.;
 
    if (segments->GetEntries()==1) {
        // in case of Single-stop. make a vertex 650 micron upstream ob base.
        EdbSegP *s = new EdbSegP(*((EdbSegP *) segments->At(0)));
        s->PropagateTo(s->Z()-650);
        xx=s->X();
        yy=s->Y();
        zz=s->Z();
        delete s;
    }
    else {
        for (int i=0; i<segments->GetEntries(); i++) {
            EdbSegP *s = (EdbSegP *) segments->At(i);
            double ax = s->TX();
            double ay = s->TY();
            double az = 1.0;
            double x  = s->X();
            double y  = s->Y();
            double z  = s->Z();
            double a = ax*ax+ay*ay+az*az;
            double c = -ax*x-ay*y-az*z;
            double b = (ax*ax+ay*ay);
            //      double w = 1.0/a/a; // weight for small angle tracks.
            double w = 1.0; // no weight
 
            Ax+=2.0*w/b*( a*(ay*ay+az*az) );
            Bx+=2.0*w/b*( -a*ax*ay );
            Cx+=2.0*w/b*( -a*ax*az );
            Dx+=2.0*w/b*( -(a*x+c*ax)*(ax*ax-a)-(a*y+c*ay)*ax*ay-(a*z+c*az)*az*ax );
 
            Ay+=2.0*w/b*( -a*ay*ax );
            By+=2.0*w/b*( a*(az*az+ax*ax) );
            Cy+=2.0*w/b*( -a*ay*az );
            Dy+=2.0*w/b*( -(a*y+c*ay)*(ay*ay-a)-(a*z+c*az)*ay*az-(a*x+c*ax)*ax*ay );
 
            Az+=2.0*w/b*( -a*az*ax );
            Bz+=2.0*w/b*( -a*az*ay );
            Cz+=2.0*w/b*( a*b );
            Dz+=2.0*w/b*( -(a*z+c*az)*(az*az-a)-(a*x+c*ax)*az*ax-(a*y+c*ay)*ay*az );
 
        }
 
        Det=fabs( Ax*(By*Cz-Cy*Bz)-Bx*(Ay*Cz-Cy*Az)+Cx*(Ay*Bz-By*Az) );
        xx=( (By*Cz-Cy*Bz)*Dx-(Bx*Cz-Cx*Bz)*Dy+(Bx*Cy-Cx*By)*Dz)/Det;
        yy=(-(Ay*Cz-Cy*Az)*Dx+(Ax*Cz-Cx*Az)*Dy-(Ax*Cy-Cx*Ay)*Dz)/Det;
        zz=( (Ay*Bz-By*Az)*Dx-(Ax*Bz-Bx*Az)*Dy+(Ax*By-Bx*Ay)*Dz)/Det;
    }
 
    EdbVertex *v = new EdbVertex();
    v->SetXYZ(xx,yy,zz);
 
    return v;
}

Check_ParasetDefinitionFile()

Int_t Check_ParasetDefinitionFile

(

)

{
    Log(2, "ShowRec.cpp", "--- Int_t Check_ParasetDefinitionFile() ---");
 
    string filename = "PARAMETERSET_DEFINITIONFILE.root";
    ifstream fin( filename.c_str() );
    if ( !fin ) {
        cout << "WARNING: In --- Check_ParasetDefinitionFile ---  ";
        cout << "Opening " << filename << " failed. Using only one, standard parameterset." << endl;
        return 1;
    }
 
    return 0;
}

CheckInputParameters()

void CheckInputParameters

(

)

{
    if (cmd_BTPA>4 ) {
        cout << "CheckInputParameters: cmd_BTPA>4 not supported. Here it has no effect but please check your nput!"<<endl;
    }
    if (cmd_BGTP>43) {
        cout << "CheckInputParameters: cmd_BGTP>43 not supported. Here it has no effect but pleas check your input!"<<endl;
    }
    if (cmd_ALTP>8) {
        cout << "CheckInputParameters: cmd_ALTP>8 not supported. Please check your input!"<<endl;
    }
 
    if (cmd_FP<1) {
        cout << "CheckInputParameters: cmd_FP<1. Set cmd_FP=1;"<<endl;
        cmd_FP=1;
    }
    if (cmd_LP>57) {
        cout << "CheckInputParameters: cmd_LP>57. Set cmd_LP=57;"<<endl;
        cmd_LP=57;
    }
    if (cmd_MP<cmd_FP) {
        cout << "CheckInputParameters: cmd_MP<cmd_FP. Set cmd_MP=cmd_FP;"<<endl;
        cmd_MP=cmd_FP;
    }
    if (cmd_FP>cmd_LP) {
        cout << "CheckInputParameters: cmd_FP>cmd_LP. Set cmd_LP=cmd_MP+cmd_NP;"<<endl;
        cmd_LP=cmd_MP+cmd_NP;
    }
    if (cmd_MP>cmd_LP) {
        cout << "CheckInputParameters: cmd_MP>cmd_LP. Set cmd_LP=cmd_MP+cmd_NP;"<<endl;
        cmd_LP=cmd_MP+cmd_NP;
    }
 
 
    if (cmd_MCFL<0) {
        cout << "CheckInputParameters: cmd_MCFL<0. Absolute Number will be taken;"<<endl;
    }
 
    if (cmd_gEDBDEBUGLEVEL>5) {
        cout << "CheckInputParameters: cmd_gEDBDEBUGLEVEL>5 not supported.  Here it has no effect but pleas check your input!"<<endl;
    }
 
    return;
}

Create_NN_Alg_Histograms()

void Create_NN_Alg_Histograms

(

)

{
    var_NN__BG__SpatialDist_TestBT_To_InBT = new TH1F("var_NN__BG__SpatialDist_TestBT_To_InBT","var_NN__BG__SpatialDist_TestBT_To_InBT",1000,0,60000);
    var_NN__SG__SpatialDist_TestBT_To_InBT = new TH1F("var_NN__SG__SpatialDist_TestBT_To_InBT","var_NN__SG__SpatialDist_TestBT_To_InBT",1000,0,60000);
    var_NN__ALL__SpatialDist_TestBT_To_InBT = new TH1F("var_NN__ALL__SpatialDist_TestBT_To_InBT","var_NN__ALL__SpatialDist_TestBT_To_InBT",1000,0,60000);
 
    var_NN__BG__zDiff_TestBT_To_InBT = new TH1F("var_NN__BG__zDiff_TestBT_To_InBT","var_NN__BG__zDiff_TestBT_To_InBT",1000,0,60000);
    var_NN__SG__zDiff_TestBT_To_InBT = new TH1F("var_NN__SG__zDiff_TestBT_To_InBT","var_NN__SG__zDiff_TestBT_To_InBT",1000,0,60000);
    var_NN__ALL__zDiff_TestBT_To_InBT = new TH1F("var_NN__ALL__zDiff_TestBT_To_InBT","var_NN__ALL__zDiff_TestBT_To_InBT",1000,0,60000);
 
 
    var_NN__SG__dT_InBT_To_TestBT = new TH1F("var_NN__SG__dT_InBT_To_TestBT","var_NN__SG__dT_InBT_To_TestBT",100,0,1);
    var_NN__BG__dT_InBT_To_TestBT = new TH1F("var_NN__BG__dT_InBT_To_TestBT","var_NN__BG__dT_InBT_To_TestBT",100,0,1);
    var_NN__ALL__dT_InBT_To_TestBT = new TH1F("var_NN__ALL__dT_InBT_To_TestBT","var_NN__ALL__dT_InBT_To_TestBT",100,0,1);
 
    var_NN__SG__dR_InBT_To_TestBT = new TH1F("var_NN__SG__dR_InBT_To_TestBT","var_NN__SG__dR_InBT_To_TestBT",100,0,2000);
    var_NN__BG__dR_InBT_To_TestBT = new TH1F("var_NN__BG__dR_InBT_To_TestBT","var_NN__BG__dR_InBT_To_TestBT",100,0,2000);
    var_NN__ALL__dR_InBT_To_TestBT = new TH1F("var_NN__ALL__dR_InBT_To_TestBT","var_NN__ALL__dR_InBT_To_TestBT",100,0,2000);
 
    var_NN__SG__dR_TestBT_To_InBT = new TH1F("var_NN__SG__dR_TestBT_To_InBT","var_NN__SG__dR_TestBT_To_InBT",100,0,2000);
    var_NN__BG__dR_TestBT_To_InBT = new TH1F("var_NN__BG__dR_TestBT_To_InBT","var_NN__BG__dR_TestBT_To_InBT",100,0,2000);
    var_NN__ALL__dR_TestBT_To_InBT = new TH1F("var_NN__ALL__dR_TestBT_To_InBT","var_NN__ALL__dR_TestBT_To_InBT",100,0,2000);
 
 
 
    var_NN__SG__nseg_TestBT_To2BeforePlate = new TH1F("var_NN__SG__nseg_TestBT_To2BeforePlate","var_NN__SG__nseg_TestBT_To2BeforePlate",10,0,10);
    var_NN__BG__nseg_TestBT_To2BeforePlate = new TH1F("var_NN__BG__nseg_TestBT_To2BeforePlate","var_NN__BG__nseg_TestBT_To2BeforePlate",10,0,10);
    var_NN__ALL__nseg_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__nseg_TestBT_To2BeforePlate","var_NN__ALL__nseg_TestBT_To2BeforePlate",10,0,10);
 
    var_NN__BG__nseg_TestBT_ToBeforePlate = new TH1F("var_NN__BG__nseg_TestBT_ToBeforePlate","var_NN__BG__nseg_TestBT_ToBeforePlate",10,0,10);
    var_NN__SG__nseg_TestBT_ToBeforePlate = new TH1F("var_NN__SG__nseg_TestBT_ToBeforePlate","var_NN__SG__nseg_TestBT_ToBeforePlate",10,0,10);
    var_NN__ALL__nseg_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__nseg_TestBT_ToBeforePlate","var_NN__ALL__nseg_TestBT_ToBeforePlate",10,0,10);
 
    var_NN__BG__nseg_TestBT_ToSamePlate = new TH1F("var_NN__BG__nseg_TestBT_ToSamePlate","var_NN__BG__nseg_TestBT_ToSamePlate",10,0,10);
    var_NN__SG__nseg_TestBT_ToSamePlate = new TH1F("var_NN__SG__nseg_TestBT_ToSamePlate","var_NN__SG__nseg_TestBT_ToSamePlate",10,0,10);
    var_NN__ALL__nseg_TestBT_ToSamePlate = new TH1F("var_NN__ALL__nseg_TestBT_ToSamePlate","var_NN__ALL__nseg_TestBT_ToSamePlate",10,0,10);
 
    var_NN__BG__nseg_TestBT_To2AfterPlate = new TH1F("var_NN__BG__nseg_TestBT_To2AfterPlate","var_NN__BG__nseg_TestBT_To2AfterPlate",10,0,10);
    var_NN__SG__nseg_TestBT_To2AfterPlate = new TH1F("var_NN__SG__nseg_TestBT_To2AfterPlate","var_NN__SG__nseg_TestBT_To2AfterPlate",10,0,10);
    var_NN__ALL__nseg_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__nseg_TestBT_To2AfterPlate","var_NN__ALL__nseg_TestBT_To2AfterPlate",10,0,10);
 
    var_NN__BG__nseg_TestBT_ToAfterPlate = new TH1F("var_NN__BG__nseg_TestBT_ToAfterPlate","var_NN__BG__nseg_TestBT_ToAfterPlate",10,0,10);
    var_NN__SG__nseg_TestBT_ToAfterPlate = new TH1F("var_NN__SG__nseg_TestBT_ToAfterPlate","var_NN__SG__nseg_TestBT_ToAfterPlate",10,0,10);
    var_NN__ALL__nseg_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__nseg_TestBT_ToAfterPlate","var_NN__ALL__nseg_TestBT_ToAfterPlate",10,0,10);
 
 
 
    var_NN__BG__mean_dT_TestBT_ToSamePlate = new TH1F("var_NN__BG__mean_dT_TestBT_ToSamePlate","var_NN__BG__mean_dT_TestBT_ToSamePlate",100,0,0.2);
    var_NN__SG__mean_dT_TestBT_ToSamePlate = new TH1F("var_NN__SG__mean_dT_TestBT_ToSamePlate","var_NN__SG__mean_dT_TestBT_ToSamePlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_ToSamePlate = new TH1F("var_NN__ALL__mean_dT_TestBT_ToSamePlate","var_NN__ALL__mean_dT_TestBT_ToSamePlate",100,0,0.2);
 
    var_NN__BG__mean_dR_TestBT_ToSamePlate = new TH1F("var_NN__BG__mean_dR_TestBT_ToSamePlate","var_NN__BG__mean_dR_TestBT_ToSamePlate",100,0,800);
    var_NN__SG__mean_dR_TestBT_ToSamePlate = new TH1F("var_NN__SG__mean_dR_TestBT_ToSamePlate","var_NN__SG__mean_dR_TestBT_ToSamePlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_ToSamePlate = new TH1F("var_NN__ALL__mean_dR_TestBT_ToSamePlate","var_NN__ALL__mean_dR_TestBT_ToSamePlate",100,0,800);
 
 
    var_NN__SG__mean_dR_TestBT_ToAfterPlate = new TH1F("var_NN__SG__mean_dR_TestBT_ToAfterPlate","var_NN__SG__mean_dR_TestBT_ToAfterPlate",100,0,800);
    var_NN__BG__mean_dR_TestBT_ToAfterPlate = new TH1F("var_NN__BG__mean_dR_TestBT_ToAfterPlate","var_NN__BG__mean_dR_TestBT_ToAfterPlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__mean_dR_TestBT_ToAfterPlate","var_NN__ALL__mean_dR_TestBT_ToAfterPlate",100,0,800);
 
    var_NN__SG__mean_dT_TestBT_ToAfterPlate = new TH1F("var_NN__SG__mean_dT_TestBT_ToAfterPlate","var_NN__SG__mean_dT_TestBT_ToAfterPlate",100,0,0.2);
    var_NN__BG__mean_dT_TestBT_ToAfterPlate = new TH1F("var_NN__BG__mean_dT_TestBT_ToAfterPlate","var_NN__BG__mean_dT_TestBT_ToAfterPlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__mean_dT_TestBT_ToAfterPlate","var_NN__ALL__mean_dT_TestBT_ToAfterPlate",100,0,0.2);
 
 
    var_NN__SG__mean_dR_TestBT_To2AfterPlate = new TH1F("var_NN__SG__mean_dR_TestBT_To2AfterPlate","var_NN__SG__mean_dR_TestBT_To2AfterPlate",100,0,800);
    var_NN__BG__mean_dR_TestBT_To2AfterPlate = new TH1F("var_NN__BG__mean_dR_TestBT_To2AfterPlate","var_NN__BG__mean_dR_TestBT_To2AfterPlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__mean_dR_TestBT_To2AfterPlate","var_NN__ALL__mean_dR_TestBT_To2AfterPlate",100,0,800);
 
    var_NN__SG__mean_dT_TestBT_To2AfterPlate = new TH1F("var_NN__SG__mean_dT_TestBT_To2AfterPlate","var_NN__SG__mean_dT_TestBT_To2AfterPlate",100,0,0.2);
    var_NN__BG__mean_dT_TestBT_To2AfterPlate = new TH1F("var_NN__BG__mean_dT_TestBT_To2AfterPlate","var_NN__BG__mean_dT_TestBT_To2AfterPlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__mean_dT_TestBT_To2AfterPlate","var_NN__ALL__mean_dT_TestBT_To2AfterPlate",100,0,0.2);
 
    var_NN__SG__mean_dR_TestBT_ToBeforePlate = new TH1F("var_NN__SG__mean_dR_TestBT_ToBeforePlate","var_NN__SG__mean_dR_TestBT_ToBeforePlate",100,0,800);
    var_NN__BG__mean_dR_TestBT_ToBeforePlate = new TH1F("var_NN__BG__mean_dR_TestBT_ToBeforePlate","var_NN__BG__mean_dR_TestBT_ToBeforePlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__mean_dR_TestBT_ToBeforePlate","var_NN__ALL__mean_dR_TestBT_ToBeforePlate",100,0,800);
 
    var_NN__SG__mean_dT_TestBT_ToBeforePlate = new TH1F("var_NN__SG__mean_dT_TestBT_ToBeforePlate","var_NN__SG__mean_dT_TestBT_ToBeforePlate",100,0,0.2);
    var_NN__BG__mean_dT_TestBT_ToBeforePlate = new TH1F("var_NN__BG__mean_dT_TestBT_ToBeforePlate","var_NN__BG__mean_dT_TestBT_ToBeforePlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__mean_dT_TestBT_ToBeforePlate","var_NN__ALL__mean_dT_TestBT_ToBeforePlate",100,0,0.2);
 
 
    var_NN__SG__mean_dR_TestBT_To2BeforePlate = new TH1F("var_NN__SG__mean_dR_TestBT_To2BeforePlate","var_NN__SG__mean_dR_TestBT_To2BeforePlate",100,0,800);
    var_NN__BG__mean_dR_TestBT_To2BeforePlate = new TH1F("var_NN__BG__mean_dR_TestBT_To2BeforePlate","var_NN__BG__mean_dR_TestBT_To2BeforePlate",100,0,800);
    var_NN__ALL__mean_dR_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__mean_dR_TestBT_To2BeforePlate","var_NN__ALL__mean_dR_TestBT_To2BeforePlate",100,0,800);
 
    var_NN__SG__mean_dT_TestBT_To2BeforePlate = new TH1F("var_NN__SG__mean_dT_TestBT_To2BeforePlate","var_NN__SG__mean_dT_TestBT_To2BeforePlate",100,0,0.2);
    var_NN__BG__mean_dT_TestBT_To2BeforePlate = new TH1F("var_NN__BG__mean_dT_TestBT_To2BeforePlate","var_NN__BG__mean_dT_TestBT_To2BeforePlate",100,0,0.2);
    var_NN__ALL__mean_dT_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__mean_dT_TestBT_To2BeforePlate","var_NN__ALL__mean_dT_TestBT_To2BeforePlate",100,0,0.2);
 
    //---------
 
    var_NN__BG__min_dT_TestBT_ToSamePlate = new TH1F("var_NN__BG__min_dT_TestBT_ToSamePlate","var_NN__BG__min_dT_TestBT_ToSamePlate",100,0,0.2);
    var_NN__SG__min_dT_TestBT_ToSamePlate = new TH1F("var_NN__SG__min_dT_TestBT_ToSamePlate","var_NN__SG__min_dT_TestBT_ToSamePlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_ToSamePlate = new TH1F("var_NN__ALL__min_dT_TestBT_ToSamePlate","var_NN__ALL__min_dT_TestBT_ToSamePlate",100,0,0.2);
 
    var_NN__BG__min_dR_TestBT_ToSamePlate = new TH1F("var_NN__BG__min_dR_TestBT_ToSamePlate","var_NN__BG__min_dR_TestBT_ToSamePlate",100,0,800);
    var_NN__SG__min_dR_TestBT_ToSamePlate = new TH1F("var_NN__SG__min_dR_TestBT_ToSamePlate","var_NN__SG__min_dR_TestBT_ToSamePlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_ToSamePlate = new TH1F("var_NN__ALL__min_dR_TestBT_ToSamePlate","var_NN__ALL__min_dR_TestBT_ToSamePlate",100,0,800);
 
 
    var_NN__SG__min_dR_TestBT_ToAfterPlate = new TH1F("var_NN__SG__min_dR_TestBT_ToAfterPlate","var_NN__SG__min_dR_TestBT_ToAfterPlate",100,0,800);
    var_NN__BG__min_dR_TestBT_ToAfterPlate = new TH1F("var_NN__BG__min_dR_TestBT_ToAfterPlate","var_NN__BG__min_dR_TestBT_ToAfterPlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__min_dR_TestBT_ToAfterPlate","var_NN__ALL__min_dR_TestBT_ToAfterPlate",100,0,800);
 
    var_NN__SG__min_dT_TestBT_ToAfterPlate = new TH1F("var_NN__SG__min_dT_TestBT_ToAfterPlate","var_NN__SG__min_dT_TestBT_ToAfterPlate",100,0,0.2);
    var_NN__BG__min_dT_TestBT_ToAfterPlate = new TH1F("var_NN__BG__min_dT_TestBT_ToAfterPlate","var_NN__BG__min_dT_TestBT_ToAfterPlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_ToAfterPlate = new TH1F("var_NN__ALL__min_dT_TestBT_ToAfterPlate","var_NN__ALL__min_dT_TestBT_ToAfterPlate",100,0,0.2);
 
 
    var_NN__SG__min_dR_TestBT_To2AfterPlate = new TH1F("var_NN__SG__min_dR_TestBT_To2AfterPlate","var_NN__SG__min_dR_TestBT_To2AfterPlate",100,0,800);
    var_NN__BG__min_dR_TestBT_To2AfterPlate = new TH1F("var_NN__BG__min_dR_TestBT_To2AfterPlate","var_NN__BG__min_dR_TestBT_To2AfterPlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__min_dR_TestBT_To2AfterPlate","var_NN__ALL__min_dR_TestBT_To2AfterPlate",100,0,800);
 
    var_NN__SG__min_dT_TestBT_To2AfterPlate = new TH1F("var_NN__SG__min_dT_TestBT_To2AfterPlate","var_NN__SG__min_dT_TestBT_To2AfterPlate",100,0,0.2);
    var_NN__BG__min_dT_TestBT_To2AfterPlate = new TH1F("var_NN__BG__min_dT_TestBT_To2AfterPlate","var_NN__BG__min_dT_TestBT_To2AfterPlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_To2AfterPlate = new TH1F("var_NN__ALL__min_dT_TestBT_To2AfterPlate","var_NN__ALL__min_dT_TestBT_To2AfterPlate",100,0,0.2);
 
    var_NN__SG__min_dR_TestBT_ToBeforePlate = new TH1F("var_NN__SG__min_dR_TestBT_ToBeforePlate","var_NN__SG__min_dR_TestBT_ToBeforePlate",100,0,800);
    var_NN__BG__min_dR_TestBT_ToBeforePlate = new TH1F("var_NN__BG__min_dR_TestBT_ToBeforePlate","var_NN__BG__min_dR_TestBT_ToBeforePlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__min_dR_TestBT_ToBeforePlate","var_NN__ALL__min_dR_TestBT_ToBeforePlate",100,0,800);
 
    var_NN__SG__min_dT_TestBT_ToBeforePlate = new TH1F("var_NN__SG__min_dT_TestBT_ToBeforePlate","var_NN__SG__min_dT_TestBT_ToBeforePlate",100,0,0.2);
    var_NN__BG__min_dT_TestBT_ToBeforePlate = new TH1F("var_NN__BG__min_dT_TestBT_ToBeforePlate","var_NN__BG__min_dT_TestBT_ToBeforePlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_ToBeforePlate = new TH1F("var_NN__ALL__min_dT_TestBT_ToBeforePlate","var_NN__ALL__min_dT_TestBT_ToBeforePlate",100,0,0.2);
 
 
    var_NN__SG__min_dR_TestBT_To2BeforePlate = new TH1F("var_NN__SG__min_dR_TestBT_To2BeforePlate","var_NN__SG__min_dR_TestBT_To2BeforePlate",100,0,800);
    var_NN__BG__min_dR_TestBT_To2BeforePlate = new TH1F("var_NN__BG__min_dR_TestBT_To2BeforePlate","var_NN__BG__min_dR_TestBT_To2BeforePlate",100,0,800);
    var_NN__ALL__min_dR_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__min_dR_TestBT_To2BeforePlate","var_NN__ALL__min_dR_TestBT_To2BeforePlate",100,0,800);
 
    var_NN__SG__min_dT_TestBT_To2BeforePlate = new TH1F("var_NN__SG__min_dT_TestBT_To2BeforePlate","var_NN__SG__min_dT_TestBT_To2BeforePlate",100,0,0.2);
    var_NN__BG__min_dT_TestBT_To2BeforePlate = new TH1F("var_NN__BG__min_dT_TestBT_To2BeforePlate","var_NN__BG__min_dT_TestBT_To2BeforePlate",100,0,0.2);
    var_NN__ALL__min_dT_TestBT_To2BeforePlate = new TH1F("var_NN__ALL__min_dT_TestBT_To2BeforePlate","var_NN__ALL__min_dT_TestBT_To2BeforePlate",100,0,0.2);
 
    return;
}

CreateOutPutStructures()

void CreateOutPutStructures

(

)

                              {
 
    Log(2, "ShowRec.cpp", "--- void CreateOutPutStructures() ---");
 
    // Create unique Outputfile where efficencies and purities are written in:
    //-----------------------------------
    STREAM_ShowRecEffName="ShowRecEff__PADI_"+TString(Form("%d",cmd_PADI))+"_BTPA_"+TString(Form("%d",cmd_BTPA))+"_BGTP_"+TString(Form("%d",cmd_BGTP))+"_ALTP_"+TString(Form("%d",cmd_ALTP))+"_FP_"+TString(Form("%d",cmd_FP))+"_MP_"+TString(Form("%d",cmd_MP))+"_NP_"+TString(Form("%d",cmd_NP))+"_LT_"+TString(Form("%d",cmd_LT))+"_MC_"+TString(Form("%d",cmd_MC))+"_FZHP_"+TString(Form("%d",cmd_FZHP))+"__ParaSet_"+TString(Form("%d",cmd_PASTART))+"_To_"+TString(Form("%d",cmd_PAEND))+".txt";
    //------------------
    STRING_ShowShowerName="ShowRecShower__PADI_"+TString(Form("%d",cmd_PADI))+"_BTPA_"+TString(Form("%d",cmd_BTPA))+"_BGTP_"+TString(Form("%d",cmd_BGTP))+"_ALTP_"+TString(Form("%d",cmd_ALTP))+"_FP_"+TString(Form("%d",cmd_FP))+"_MP_"+TString(Form("%d",cmd_MP))+"_NP_"+TString(Form("%d",cmd_NP))+"_LT_"+TString(Form("%d",cmd_LT))+"_MC_"+TString(Form("%d",cmd_MC))+"_FZHP_"+TString(Form("%d",cmd_FZHP))+"__ParaSet_"+TString(Form("%d",cmd_PASTART))+"_To_"+TString(Form("%d",cmd_PAEND))+".txt";
    FILE_ShowShower = new TFile(STRING_ShowShowerName+".root","RECREATE");
    //------------------
    STRING_ShowTracksName="ShowRecTracks__PADI_"+TString(Form("%d",cmd_PADI))+"_BTPA_"+TString(Form("%d",cmd_BTPA))+"_BGTP_"+TString(Form("%d",cmd_BGTP))+"_ALTP_"+TString(Form("%d",cmd_ALTP))+"_FP_"+TString(Form("%d",cmd_FP))+"_MP_"+TString(Form("%d",cmd_MP))+"_NP_"+TString(Form("%d",cmd_NP))+"_LT_"+TString(Form("%d",cmd_LT))+"_MC_"+TString(Form("%d",cmd_MC))+"_FZHP_"+TString(Form("%d",cmd_FZHP))+"__ParaSet_"+TString(Form("%d",cmd_PASTART))+"_To_"+TString(Form("%d",cmd_PAEND))+".txt";
    FILE_ShowTracks = new TFile(STRING_ShowTracksName+".root","RECREATE");
    //------------------
    TString HistoOutputFile="ShowRecHistos__PADI_"+TString(Form("%d",cmd_PADI))+"_BTPA_"+TString(Form("%d",cmd_BTPA))+"_BGTP_"+TString(Form("%d",cmd_BGTP))+"_ALTP_"+TString(Form("%d",cmd_ALTP))+"_FP_"+TString(Form("%d",cmd_FP))+"_MP_"+TString(Form("%d",cmd_MP))+"_NP_"+TString(Form("%d",cmd_NP))+"_LT_"+TString(Form("%d",cmd_LT))+"_MC_"+TString(Form("%d",cmd_MC))+"_FZHP_"+TString(Form("%d",cmd_FZHP))+"__ParaSet_"+TString(Form("%d",cmd_PASTART))+"_To_"+TString(Form("%d",cmd_PAEND))+".txt";
    FILE_ShowRecHistos = new TFile(HistoOutputFile+".root","RECREATE");
    //------------------
 
    cout << "--- void CreateOutPutStructures() --- Root Files Recreated."<<endl;
 
    NBTeMC_pure      = new TProfile("NBTeMCvspure","NBTeMCvspure",100,0,1.05,0,300);
    NBTallMC_purall  = new TProfile("NBTallMCvspurall","NBTallMCvspurall",100,0,1.05,0,300);
    NBTeMC_NBTMC = new TProfile("NBTeMCvsNBTMC","NBTeMCvsNBTMC",100,0,200,0,300);
    NBTeMC_NBT = new TProfile("NBTeMCvsNBT","NBTeMCvsNBT",100,0,200,0,300);
    NBT_InBTE = new TProfile("NBTvsInBTE","NBTvsInBTE",100,0,30,0,300);
    NBTeMC_InBTE = new TProfile("NBTeMCvsInBTE","NBTeMCvsInBTE",100,0,30,0,300);
    pure_InBTE = new TProfile("pure_InBTE","pure_InBTE",100,0,30,0,1.05);
    purall_InBTE = new TProfile("purall_InBTE","purall_InBTE",100,0,30,0,1.05);
 
    Hist_NBTeMC_pure = new TH2F("Hist_NBTeMC_pure","Hist_NBTeMC_pure",105,0,1.05,200,0,400);
    Hist_NBTallMC_purall = new TH2F("Hist_NBTallMC_purall","Hist_NBTallMC_purall",105,0,1.05,200,0,400);
    Hist_NBTeMC_NBTMC = new TH2F("Hist_NBTeMC_NBTMC","Hist_NBTeMC_NBTMC",200,0,400,200,0,200);
    Hist_NBTeMC_NBT = new TH2F("Hist_NBTeMC_NBT","Hist_NBTeMC_NBT",200,0,400,200,0,200);
    Hist_NBT_InBTE = new TH2F("Hist_NBT_InBTE","Hist_NBT_InBTE",120,0,30,200,0,200);
    Hist_NBTeMC_InBTE = new TH2F("Hist_NBTeMC_InBTE","Hist_NBTeMC_InBTE",120,0,30,200,0,200);
    Hist_pure_InBTE = new TH2F("Hist_pure_InBTE","Hist_pure_InBTE",120,0,30,100,0,1.05);
    Hist_purall_InBTE = new TH2F("Hist_purall_InBTE","Hist_purall_InBTE",120,0,30,100,0,1.05);
 
 
    cout << "--- void CreateOutPutStructures() --- Histos Recreated."<<endl;
    //------------------
    FILE_ShowRecEff = new TFile(STREAM_ShowRecEffName+".root","RECREATE");
    TREE_ShowRecEff = new TTree("TreeSTREAM_ShowRecEff","TreeWithvaluesEqualToSTREAM_ShowRecEffTextFile");
    TREE_ShowRecEff->SetDirectory(FILE_ShowRecEff);
    cout << "--- void CreateOutPutStructures() --- Tree Recreated."<<endl;
    //-----------------------------------
    TREE_ShowRecEff->Branch("PADI", &cmd_PADI, "PADI/I");
    TREE_ShowRecEff->Branch("BTPA", &cmd_BTPA, "BTPA/I");
    TREE_ShowRecEff->Branch("BGTP", &cmd_BGTP, "BGTP/I");
    TREE_ShowRecEff->Branch("ALTP", &cmd_ALTP, "ALTP/I");
 
    TREE_ShowRecEff->Branch("FP", &cmd_FP, "FP/I");
    TREE_ShowRecEff->Branch("MP", &cmd_MP, "MP/I");
    TREE_ShowRecEff->Branch("LP", &cmd_LP, "LP/I");
    TREE_ShowRecEff->Branch("NP", &cmd_NP, "NP/I");
 
    TREE_ShowRecEff->Branch("LT", &cmd_LT, "LT/I");
    TREE_ShowRecEff->Branch("MC", &cmd_MC, "MC/I");
 
    TREE_ShowRecEff->Branch("PARASETNR", &GLOBAL_PARASETNR, "PARASETNR/I");
    TREE_ShowRecEff->Branch("ShowerNr", &GLOBAL_INBTSHOWERNR, "ShowerNr/I");
 
    TREE_ShowRecEff->Branch("EvtBT_E", &GLOBAL_EvtBT_E, "EvtBT_E/D");
    TREE_ShowRecEff->Branch("EvtBT_TanTheta", &GLOBAL_EvtBT_TanTheta, "EvtBT_TanTheta/D");
    TREE_ShowRecEff->Branch("EvtBT_Flag", &GLOBAL_EvtBT_Flag, "EvtBT_Flag/I");
    TREE_ShowRecEff->Branch("EvtBT_MC", &GLOBAL_EvtBT_MC, "EvtBT_MC/I");
 
    TREE_ShowRecEff->Branch("InBT_E", &GLOBAL_InBT_E, "InBT_E/D");
    TREE_ShowRecEff->Branch("InBT_TanTheta", &GLOBAL_InBT_TanTheta, "InBT_TanTheta/D");
    TREE_ShowRecEff->Branch("InBT_Flag", &GLOBAL_InBT_Flag, "InBT_Flag/I");
    TREE_ShowRecEff->Branch("InBT_MC", &GLOBAL_InBT_MC, "InBT_MC/I");
 
    TREE_ShowRecEff->Branch("NBT", &GLOBAL_NBT, "NBT/I");
    TREE_ShowRecEff->Branch("NBTMC", &GLOBAL_NBTMC, "NBTMC/I"); // kept for backward compability
    TREE_ShowRecEff->Branch("NBTallMC", &GLOBAL_NBTallMC, "NBTallMC/I");
    TREE_ShowRecEff->Branch("NBTeMC", &GLOBAL_NBTeMC, "NBTeMC/I");
    TREE_ShowRecEff->Branch("purall", &GLOBAL_purall, "purall/D");
    TREE_ShowRecEff->Branch("pure", &GLOBAL_pure, "pure/D");
    TREE_ShowRecEff->Branch("effall", &GLOBAL_effall, "effall/D");
    TREE_ShowRecEff->Branch("effe", &GLOBAL_effe, "effe/D");
 
    TREE_ShowRecEff->Branch("trckdens", &GLOBAL_trckdens, "trckdens/D");
    //-----------------------------------
    Log(2, "ShowRec.cpp", "--- void CreateOutPutStructures() ---done.");
    return;
}

CreateTreeBranchShowerTree()

TTree* CreateTreeBranchShowerTree

(

Int_t

ParaSetNr

)

{
    Log(2, "ShowRec.cpp", "--- TTree* CreateTreeBranchShowerTree() ---");
 
 
    // ParasetNr == -1 (no paraset from the paradefinition.root file is given and the
    // standard built in parasets are used: "treebranch" instead of "treebranch_-1"
    // ParasetNr != -1 ( paraset from the paradefinition.root file is given)
 
    TString treenname;
    if (ParaSetNr==-1) {
        treenname="treebranch";
    }
    else {
        treenname=TString(Form("treebranch_%d",ParaSetNr));
    }
 
    TTree* eShowerTree = new TTree(treenname,treenname);
    eShowerTree->Branch("number_eventb",&shower_number_eventb,"number_eventb/I");
    eShowerTree->Branch("sizeb",&shower_sizeb,"sizeb/I");
    eShowerTree->Branch("sizeb15",&shower_sizeb15,"sizeb15/I");
    eShowerTree->Branch("sizeb20",&shower_sizeb20,"sizeb20/I");
    eShowerTree->Branch("sizeb30",&shower_sizeb30,"sizeb30/I");
    eShowerTree->Branch("isizeb",&shower_isizeb,"isizeb/I");
    eShowerTree->Branch("xb",shower_xb,"xb[sizeb]/F");
    eShowerTree->Branch("yb",shower_yb,"yb[sizeb]/F");
    eShowerTree->Branch("zb",shower_zb,"zb[sizeb]/F");
    eShowerTree->Branch("txb",shower_txb,"txb[sizeb]/F");
    eShowerTree->Branch("tyb",shower_tyb,"tyb[sizeb]/F");
    eShowerTree->Branch("nfilmb",shower_nfilmb,"nfilmb[sizeb]/I");
    eShowerTree->Branch("ntrace1simub",shower_ntrace1simub,"ntrace1simu[sizeb]/I",128000);  // s.eMCEvt
    eShowerTree->Branch("ntrace2simub",shower_ntrace2simub,"ntrace2simu[sizeb]/I",128000); // s.eW
    eShowerTree->Branch("ntrace3simub",shower_ntrace3simub,"ntrace3simu[sizeb]/F",128000); // s.eP
    eShowerTree->Branch("ntrace4simub",shower_ntrace4simub,"ntrace4simu[sizeb]/I",128000); // s.eFlag
    eShowerTree->Branch("chi2btkb",shower_chi2btkb,"chi2btkb[sizeb]/F");
    eShowerTree->Branch("deltarb",shower_deltarb,"deltarb[sizeb]/F");
    eShowerTree->Branch("deltathetab",shower_deltathetab,"deltathetab[sizeb]/F");
    eShowerTree->Branch("deltaxb",shower_deltaxb,"deltaxb[sizeb]/F");
    eShowerTree->Branch("deltayb",shower_deltayb,"deltayb[sizeb]/F");
    eShowerTree->Branch("tagprimary",shower_tagprimary,"tagprimary[sizeb]/F");
    eShowerTree->Branch("energy_shot_particle",&shower_energy_shot_particle,"energy_shot_particle/F");
    eShowerTree->Branch("E_MC",&shower_energy_shot_particle,"E_MC/F");
    eShowerTree->Branch("showerID",&shower_showerID,"showerID/I");
    eShowerTree->Branch("idb",shower_idb,"idb/I");
    eShowerTree->Branch("plateb",shower_plateb,"plateb[sizeb]/I");
    eShowerTree->Branch("deltasigmathetab",shower_deltasigmathetab,"deltasigmathetab[59]/F");
    eShowerTree->Branch("lengthfilmb",&shower_numberofilms,"lengthfilmb/I",128000);
    eShowerTree->Branch("purityb",&shower_purb,"purityb/F",128000); // shower purity
    eShowerTree->Branch("trackdensb",&shower_trackdensb,"trackdensb/F",128000); // track density _around_ the shower (not _in_ shower)
    eShowerTree->Branch("nholesb",&shower_numberofholes,"nholesb/I",128000); // #of (single) empty plates
    eShowerTree->Branch("nholesmaxb",&shower_numberofholesconseq,"nholesmaxb/I",128000); // #of (consecutive) empty plates
 
    eShowerTree->Branch("axis_xb",&shower_axis_xb,"shower_axis_xb/F"); // Shower Axis Values...
    eShowerTree->Branch("axis_yb",&shower_axis_yb,"shower_axis_yb/F");
    eShowerTree->Branch("axis_zb",&shower_axis_zb,"shower_axis_zb/F");
    eShowerTree->Branch("axis_txb",&shower_axis_txb,"shower_axis_txb/F");
    eShowerTree->Branch("axis_tyb",&shower_axis_tyb,"shower_axis_tyb/F");
 
    // distuingish variable for more than one kind of showers merged into treebranch
    eShowerTree->Branch("filetype",&shower_filetype,"filetype/I");
 
    eShowerTree->SetDirectory(FILE_ShowShower);
 
    if (gEDBDEBUGLEVEL>2) {
        cout << "--- CreateTreeBranchShowerTree: eShowerTree: Name, Entries:"<<endl;
        cout << eShowerTree->GetName() << "    " << eShowerTree->GetEntries() <<endl;
        cout << "------eShowerTree-----------------------------------------"<<endl;
    }
    return eShowerTree;
}

Fill2GlobalInBTArray()

void Fill2GlobalInBTArray

(

)

                            {
 
    // if we have a vertex file we can cut for InBT tracks with a given vertex (to pure up the starting inbt sample)
    // (for now 100micron ip). (electrons,pi+-);
    // (for now 250micron ip). (photons.);
    // (for now 300micron ip). (other.);
//   if (cmd_vtx!=1) return;
    if (cmd_vtx==0) return;
//     if (cmd_MC!=1) return; // why did we say that we wanna have only starting mc inbts?
    // also it can be possible that we wanna seacrh all in bt from the volume to an given
    //  vertex, for a mc event (but not necessarily for mc In BTs).
    // better comment it out?... ah, i know why because otherwise, we do not know which mc event vtx to take... so what to do???
 
    Float_t cutIPMax=100;
    if (cmd_vtx==2) cutIPMax=250;
    if (cmd_vtx==3) cutIPMax=500;
    if (cmd_vtx==4) cutIPMax=1000;
    if (cmd_vtx==5) cutIPMax=5000;
 
    Float_t cutZVtxDist=999999;
 
    TObjArray* GLOBAL_InBTArray2 = new TObjArray();
    cout << "Fill2GlobalInBTArray Calc IPs for the " << GLOBAL_InBTArray->GetEntries() << " entries" << endl;
 
    for (Int_t i=0; i<GLOBAL_InBTArray->GetEntries(); ++i) {
        if (i%1000==0) cout << "." << flush;
        EdbSegP* s1=(EdbSegP*)GLOBAL_InBTArray->At(i);
        // Calculate IP:
        // in case InBT is of BGType, we check for the GBMC variable set.
        Int_t MCEvt=s1->MCEvt();
        if (MCEvt<0 && cmd_GBMC>0) MCEvt=cmd_GBMC;
 
        Double_t ip=CalcIP(s1,Double_t(GLOBAL_VtxArrayX[MCEvt]),Double_t(GLOBAL_VtxArrayY[MCEvt]),Double_t(GLOBAL_VtxArrayZ[MCEvt]));
 
        if (ip>cutIPMax) continue;
 
        cutZVtxDist=s1->Z()-Double_t(GLOBAL_VtxArrayZ[MCEvt]);
        if (i==0||i==GLOBAL_InBTArray->GetEntries()-1) {
            cout << "INBT " << i << " :VTX:X:Y:Z:  " << GLOBAL_VtxArrayX[MCEvt] << " " << GLOBAL_VtxArrayY[MCEvt] << " " << GLOBAL_VtxArrayZ[MCEvt] << " ip= " << ip << " ZdistVtx=  " <<  cutZVtxDist << " MCEvt= " << MCEvt << endl;
        }
 
        if (ip<cutIPMax) GLOBAL_InBTArray2->Add(s1);
    }
 
    cout << endl;
    cout << "Fill2GlobalInBTArray::Before IP cut " << GLOBAL_InBTArray->GetEntries() << endl;
    cout << "Fill2GlobalInBTArray::After IP cut("<<cutIPMax<<") " << GLOBAL_InBTArray2->GetEntries() << endl;
// Swap Arrays:
    GLOBAL_InBTArray= GLOBAL_InBTArray2;
    cout << GLOBAL_InBTArray->GetEntries() <<endl;
 
 
    return;
}

FillGlobalInBTArray()

void FillGlobalInBTArray

(

)

MAYBE THIS DOESNT YET WORK FOR DOWNSTREAM LINKINT TYPE if (s2->PID()>firstplate) continue; if (s2->PID()<middleplate) continue;

TEST, now we choose something different, ratio of highest P to other thrack: <10 if (TMath::Abs(highestP_at_lowestZ[jjjj]-highestP[jjjj])>200.0) {

— ONLY DEBUG —

— ONLY DEBUG —

{
    Log(2, "ShowRec.cpp", "--- void FillGlobalInBTArray() ---");
 
    //--------------------------------------------------------
    // To fill the Initiator BT array from the gAli
    // watching boundary conditions for the Plates, MC Cut.
    //--------------------------------------------------------
    GLOBAL_InBTArray = new TObjArray(99999);
    GLOBAL_ShowerSegArray = new TObjArray(99999);
    EdbSegP     *segment;
    //--------------------------------------------------------
    // Informational Debug Output
    cout << "---!! DOWNSTREAM ORDER ASSUMED !!---"<<endl;
    cout << "---!! IF PROGRAM CRASH HERE, CHECK YOUR INPUT FP,NP;MP;LP !!---"<<endl;
    Int_t npat = GLOBAL_gAli->Npatterns();  //number of plates
    Int_t firstplate= npat-cmd_FP;
    Int_t middleplate= npat-cmd_MP;
    Int_t actualplate= npat-cmd_FP;
    Int_t lastplate= TMath::Max(npat-cmd_LP-1,0);
    Float_t GLOBAL_gAli__firstplate_Z=GLOBAL_gAli->GetPattern(firstplate)->Z();
    Float_t GLOBAL_gAli__middleplate_Z=GLOBAL_gAli->GetPattern(middleplate)->Z();
    Float_t GLOBAL_gAli__lastplate_Z=GLOBAL_gAli->GetPattern(lastplate)->Z();
    //--------------------------------------------------------
    if (gEDBDEBUGLEVEL>2) {
        cout << "--- FillGlobalInBTArray: DOWNSTREAM ORDER" <<endl;
        cout << "--- npat = " << npat << endl;
        cout << "--- firstplate = " << firstplate << endl;
        cout << "--- middleplate = " << middleplate << endl;
        cout << "--- lastplate = " << lastplate << endl;
        cout << " GLOBAL_gAli->GetPattern(firstplate)->Z() =  " << GLOBAL_gAli->GetPattern(firstplate)->Z() << endl;
        cout << " GLOBAL_gAli->GetPattern(middleplate)->Z() =  " << GLOBAL_gAli->GetPattern(middleplate)->Z() << endl;
    }
    //--------------------------------------------------------
 
    // return;
 
 
    //--------------------------------------------------------
    // Do this in case of -cmd_LT==1,2,3
    // 1: all starting BTs of a track are taken.
    // 2: all ending   BTs of a track are taken.
    // 3: all          BTs of a track are taken.
    //--------------------------------------------------------
    if (cmd_LT==1||cmd_LT==2||cmd_LT==3||cmd_LT==4) {
        if (gEDBDEBUGLEVEL>2) cout << "--- Doing tracking case  cmd_LT==1,2,3,4"<<endl;
        EdbSegP * s2=0;
        EdbTrackP  *t  = 0;
        TFile * fil = new TFile("linked_tracks.root");
        TTree* tr= (TTree*)fil->Get("tracks");
        TClonesArray *seg= new TClonesArray("EdbSegP",60);
        int nentr = int(tr->GetEntries());
        int nseg,n0,npl;
        cout << nentr << "  entries Total"<<endl;
        tr->SetBranchAddress("t."  , &t  );
        tr->SetBranchAddress("s"  , &seg  );
        tr->SetBranchAddress("nseg"  , &nseg  );
        tr->SetBranchAddress("n0"  , &n0  );
        tr->SetBranchAddress("npl"  , &npl  );
        tr->Show(0);
 
        int percent=100;
        cout << "--- Doing tracking case  cmd_LT==1,2,3,4   with percent value of "<< percent << endl;
 
        for (int i=0; i<nentr; i++ ) {
            //if (i%10!=0) continue;
            tr->GetEntry(i);
            if (gEDBDEBUGLEVEL>3) tr->Show(i);
            // Take only Basetracks from tracks which pass 3 or more plates:
            if (npl<3) continue;
 
            // depending on cmd_LT=1,2,3 different loops have to be gone through:
            for (int k=0; k<nseg; k++ ) {
                //cout << "----- Doing  i= " <<  i <<  " and  k= " <<  k<< endl;
                if (cmd_LT==1 && k>0) continue;             // only first BT
                if (cmd_LT==2 && k<nseg-1) continue;        // only last BT
                // Take first BT of the tracks:
                s2=(EdbSegP*) seg->At(k);
                // Check via PID if this segment is within the desired range:
                // Only valid for upstream...
                // Test if with Z values it is better:
                if (s2->Z()>GLOBAL_gAli__lastplate_Z) continue;
                if (s2->Z()>GLOBAL_gAli__middleplate_Z) continue;
                if (s2->Z()<GLOBAL_gAli__firstplate_Z) continue;
 
                segment=(EdbSegP*)s2->Clone();
 
                if (cmd_MC==1 && segment->MCEvt()<0) continue; // do not add segment.
                if (cmd_MC==1 && cmd_MCFL>0 && Abs(segment->Flag())!=cmd_MCFL) continue; // do not add segment with wrong flag.
                else GLOBAL_InBTArray->Add(segment);   // otherwise do.
 
                if (gEDBDEBUGLEVEL>2) segment->PrintNice();
 
 
                // Case Of LT==4, take only the first BT which appears between [FP..MP]
                // Then if we have a BT for this track, we finish this loop and move to
                // the next Track:
                if (cmd_LT==4) k=nseg; // this means automatically finish this loop...
 
            } // of for(int k=0; k<nseg; k++ )
        } // for(int i=0; i<nentr; i++ )
        delete tr;
        delete fil;
 
        if (gEDBDEBUGLEVEL>2) cout << "--- Filled " << GLOBAL_InBTArray->GetEntries()  << " Segments into GLOBAL_InBTArray."<<endl;
 
    } // end of Do this in case of -cmd_LT==1
 
 
    //--------------------------------------------------------
    // Do this in case of -cmd_LT==0 && cmd_FZHP==0
    //--------------------------------------------------------
    if (cmd_MC<2&&cmd_LT==0 && cmd_FZHP==0) {
        cout << "Do this in case of cmd_MC<2&& -cmd_LT==0 && cmd_FZHP==0 " << endl;
        for (Int_t nr=middleplate; nr<=firstplate; ++nr) {
            for (Int_t n=0; n<GLOBAL_gAli->GetPattern(nr)->GetN(); ++n) {
                segment=GLOBAL_gAli->GetPattern(nr)->GetSegment(n);
                if (cmd_MC==1 && segment->MCEvt()<0) continue; // do not add segment.
                if (cmd_MC==1 && cmd_MCFL>0 && Abs(segment->Flag())!=cmd_MCFL) continue; // do not add segment with wrong flag.
                else GLOBAL_InBTArray->Add(segment);   // otherwise do.
 
                if (gEDBDEBUGLEVEL>2) segment->PrintNice();
            }
        }
    } // Do this in case of -cmd_LT==0 && cmd_FZHP==0
 
    //--------------------------------------------------------
    // Do this in case of -cmd_MC==2 (only InBT from [middleplate..middleplate]
    //--------------------------------------------------------
    if (cmd_MC==2) {
        cout << "Do this in case of cmd_MC==2 " << endl;
        for (Int_t nr=middleplate; nr<=middleplate; ++nr) {
            for (Int_t n=0; n<GLOBAL_gAli->GetPattern(nr)->GetN(); ++n) {
                segment=GLOBAL_gAli->GetPattern(nr)->GetSegment(n);
                if (cmd_MC==2 && segment->MCEvt()<0) continue; // do not add segment.
                if (cmd_MC==2 && cmd_MCFL>0 && Abs(segment->Flag())!=cmd_MCFL) continue; // do not add segment with wrong flag.
                else GLOBAL_InBTArray->Add(segment);   // otherwise do.
                if (gEDBDEBUGLEVEL>2) segment->PrintNice();
            }
        }
    } // Do this in case of  -cmd_MC==2
 
    //--------------------------------------------------------
    // Do this in case of -cmd_MC==3 (only InBT from [middleplate..lastplate]
    //--------------------------------------------------------
    if (cmd_MC==3) {
        cout << "Do this in case of cmd_MC==3 " << endl;
        for (Int_t nr=middleplate; nr<=lastplate; ++nr) {
            for (Int_t n=0; n<GLOBAL_gAli->GetPattern(nr)->GetN(); ++n) {
                segment=GLOBAL_gAli->GetPattern(nr)->GetSegment(n);
                if (cmd_MC==3 && segment->MCEvt()<0) continue; // do not add segment.
                if (cmd_MC==3 && cmd_MCFL>0 && Abs(segment->Flag())!=cmd_MCFL) continue; // do not add segment with wrong flag.
                else GLOBAL_InBTArray->Add(segment);   // otherwise do.
                if (gEDBDEBUGLEVEL>2) segment->PrintNice();
            }
        }
    } // Do this in case of  -cmd_MC==3
 
 
    //--------------------------------------------------------
    // Do this in case of cmd_MC<2 and -cmd_LT==0  and cmd_FirstZHighestP==1
    //--------------------------------------------------------
    if (cmd_MC<2&&cmd_FZHP>=1 && cmd_LT==0) {
        cout << "// Do this in case of cmd_MC<2&&cmd_FZHP>=1 && cmd_LT==0" << endl;
 
        EdbSegP* segtest=0;
        float lowestZ[99999];
        for (int i=0; i<99999; i++) {
            lowestZ[i]=9999999;
        }
        float lowestZ_at_highestP[99999];
        for (int i=0; i<99999; i++) {
            lowestZ_at_highestP[i]=9999999;
        }
        float highestP[99999];
        for (int i=0; i<99999; i++) {
            highestP[i]=-1;
        }
        float highestP_at_lowestZ[99999];
        for (int i=0; i<99999; i++) {
            highestP_at_lowestZ[i]=-1;
        }
        int lowestZPlateForEvent[99999];
        for (int i=0; i<99999; i++) {
            lowestZPlateForEvent[i]=-1;
        }
        float desiredZ[99999];
        for (int i=0; i<99999; i++) {
            desiredZ[i]=9999999;
        }
        float desiredP[99999];
        for (int i=0; i<99999; i++) {
            desiredP[i]=-1;
        }
        int maxEvt=0;
 
 
        cout << "-------------------DOING FIRST   LOOP NOW ------------------------"<<endl;
 
        Int_t helperMC=0;
 
        // First get lowest Z positions in any case,
        // and highest P value of all gAli patterns:
        for (Int_t nr=middleplate; nr<=firstplate; ++nr) {
            //cout <<" GLOBAL_gAli->GetPattern(nr)->Z() =  " << GLOBAL_gAli->GetPattern(nr)->Z() << endl;
            for (Int_t n=0; n<GLOBAL_gAli->GetPattern(nr)->GetN(); ++n) {
                segtest=GLOBAL_gAli->GetPattern(nr)->GetSegment(n);
 
                helperMC=segtest->MCEvt();
 
                if (helperMC<0) continue;
                if (helperMC>maxEvt) maxEvt=helperMC;
                if (segtest->P()>highestP[helperMC]) {
                    highestP[helperMC]=segtest->P();
                    lowestZ_at_highestP[helperMC]=segtest->Z();
                }
                if (cmd_FZHP==1&&segtest->Z()>lowestZ[helperMC]) continue;
 
                lowestZ[helperMC]=segtest->Z();
                lowestZPlateForEvent[helperMC]=nr;
            }
        }
 
 
 
        cout << "-------------------DOING 2nd   LOOP NOW ------------------------"<<endl;
 
        //     int jjjj=1780;
        //     cout << "lowestZ[jjjj] = " << lowestZ[jjjj]  <<  "  highestP[jjjj] =  "  << highestP[jjjj] << " lowestZPlateForEvent[]= " << lowestZPlateForEvent[jjjj] <<endl;
        //     cout << "highestP_at_lowestZ[jjjj] = " << highestP_at_lowestZ[jjjj]  <<  " TMath::Abs(highestP_at_lowestZ[jjjj]-highestP[jjjj])  "  <<  TMath::Abs(highestP_at_lowestZ[jjjj]-highestP[jjjj]) <<  "--lowestZ_at_highestP[jjjj]  "<<lowestZ_at_highestP[jjjj] <<  endl;
 
 
        Bool_t shuffle_sameposition_BTs=kFALSE;
        //      Bool_t shuffle_sameposition_BTs=kTRUE;
 
        // Then compare highest then look for highest P at lowest Z positions:
        for (Int_t nr=middleplate; nr<=firstplate; ++nr) {
            //cout <<" GLOBAL_gAli->GetPattern(nr)->Z() =  " << GLOBAL_gAli->GetPattern(nr)->Z() << endl;
            for (Int_t n=0; n<GLOBAL_gAli->GetPattern(nr)->GetN(); ++n) {
                segtest=GLOBAL_gAli->GetPattern(nr)->GetSegment(n);
                helperMC=segtest->MCEvt();
                if (helperMC<0) continue;
                if (nr!=lowestZPlateForEvent[helperMC]) continue;
 
                if (segtest->P()>highestP_at_lowestZ[helperMC]) {   // can comment this to shuffle first starting BTs
                    highestP_at_lowestZ[helperMC]=segtest->P();
                    desiredZ[helperMC]=segtest->Z();
                    desiredP[helperMC]=segtest->P();
                }                           // can comment this to shuffle first starting BTs
 
                // If shuffle then set the values, not even comparing "segtest->P()>highestP_at_lowestZ[helperMC]"
                if (shuffle_sameposition_BTs) {
                    highestP_at_lowestZ[helperMC]=segtest->P();
                    desiredZ[helperMC]=segtest->Z();
                    desiredP[helperMC]=segtest->P();
                }
 
            }
        }
 
        // Remark: here we take at the lowest Z position th BT which has the largest P() value. NOrmally, if you have
        // both, e+ and e- you want to reconstruct yout gamma-shower, no matter from which BT you start.
        // Test: for 2GeV and 0.5GeV Gammas the resulting shower distirbutions look already similar, if ou either start recon-
        // structing from higher P() BT, or randomly. Just a very slight shift to higher sizeb if you take higher P() BT.
 
        // Now Check for all MC events if the difference inP() is greater 200 MeV:
        //  a) if not: then take lowestZ_at_highestP with highestP
        //  b) if    : then take lowestZ with highestP_at_lowestZ
 
        cout << "-------------------DOING 3rd   LOOP NOW ------------------------"<<endl;
 
 
        for (int jjjj=1; jjjj<=maxEvt; ++jjjj) {
            if (gEDBDEBUGLEVEL>2) {
                cout << "---Event "<< jjjj << endl;
                cout << "TMath::Abs(highestP_at_lowestZ[jjjj]-highestP[jjjj]) " << TMath::Abs(highestP_at_lowestZ[jjjj]-highestP[jjjj]) << endl;
                cout << "Ratio highestP[jjjj]/highestP_at_lowestZ[jjjj] " << highestP[jjjj]/highestP_at_lowestZ[jjjj] << endl;
            }
            if (highestP[jjjj]/highestP_at_lowestZ[jjjj]>10) {
                desiredZ[jjjj]=lowestZ_at_highestP[jjjj];
                desiredP[jjjj]=highestP[jjjj];
            }
 
            if (cmd_FZHP==2) {
                desiredZ[jjjj]=lowestZ_at_highestP[jjjj];
                desiredP[jjjj]=highestP[jjjj];
            }
 
 
            if (gEDBDEBUGLEVEL>2) {
                cout << "---Event "<< jjjj << endl;
                cout << "lowestZ[jjjj] = " << lowestZ[jjjj]  <<  "  highestP[jjjj] =  "  << highestP[jjjj] << " lowestZPlateForEvent[]= " << lowestZPlateForEvent[jjjj] <<endl;
                cout << "highestP_at_lowestZ[jjjj] = " << highestP_at_lowestZ[jjjj]  <<  " TMath::Abs(highestP_at_lowestZ[jjjj]-highestP[jjjj])  "  <<  TMath::Abs(highestP_at_lowestZ[jjjj]-highestP[jjjj])    <<  "--lowestZ_at_highestP[jjjj]  "<<lowestZ_at_highestP[jjjj] <<  endl;
                cout << "desiredZ[jjjj] = " << desiredZ[jjjj]  <<  "  desiredP[jjjj] =  "  << desiredP[jjjj] << endl;
            }
        }
 
 
        cout << "-------------------DOING 4th   LOOP NOW ------------------------"<<endl;
 
        helperMC=0;
 
        for (Int_t nr=middleplate; nr<=firstplate; ++nr) {
            for (Int_t n=0; n<GLOBAL_gAli->GetPattern(nr)->GetN(); ++n) {
                segment=GLOBAL_gAli->GetPattern(nr)->GetSegment(n);
                helperMC=segment->MCEvt();
                if (cmd_MC==1 && helperMC<0) continue; // do not add segment.
                //if (cmd_MC==1 && cmd_MCFL>0 && Abs(segment->Flag())!=cmd_MCFL) continue; // do not add segment with wrong flag.
 
                if (segment->Z()!=desiredZ[helperMC]) continue; // do not add segment if it is beyond the first Z position
                if (segment->P()!=desiredP[helperMC]) continue; // do not add segment then if it is lower the highest P
                //cout <<"MCEvt " << segment->MCEvt() << " lowestZ " << lowestZ[segment->MCEvt()] << " highestP " << highestP[segment->MCEvt()] <<endl;
 
                if (helperMC>maxEvt) maxEvt=helperMC;
 
                GLOBAL_InBTArray->Add(segment);   // otherwise do.
                //if (gEDBDEBUGLEVEL>2) segment->PrintNice();
            }
        }
 
//------------------------------------  DEBUG
        for (Int_t nn=1; nn<=maxEvt; ++nn) {
            if (gEDBDEBUGLEVEL>2) cout << " MC Event ---  " << nn << "  desiredZ =  "<<  desiredZ[nn] << "  desiredP =  " <<  desiredP[nn] << "  " <<  endl;
        }
//------------------------------------
 
 
    } // Do this in case of -cmd_LT==0  and cmd_FirstZHighestP==1
 
 
    cout << "GLOBAL_InBTArray filling done.................."<<endl;
 
 
    if (GLOBAL_InBTArray->GetEntries()==0) {
        cout << "--- GLOBAL_InBTArray->GetEntries() =  0 .  RETURN FILL FUNCTION !" << endl;
        return;
    }
 
 
    if (gEDBDEBUGLEVEL>1) {
        EdbSegP* seg0=(EdbSegP*)GLOBAL_InBTArray->At(0);
        EdbSegP* segend=(EdbSegP*)GLOBAL_InBTArray->At(GLOBAL_InBTArray->GetEntries()-1);
        cout << "--- GLOBAL_InBTArray->GetEntries() =  " <<  GLOBAL_InBTArray->GetEntries() << endl;
        cout << "--- GLOBAL_InBTArray->At(0) =  " <<  endl;
        seg0->PrintNice();
        cout << "--- GLOBAL_InBTArray->At(Last) =  " << endl;
        segend->PrintNice();
    }
 
 
 
 
 
    if (gEDBDEBUGLEVEL>3) {
        int isMCThere[100000];
        int nr;
        for (Int_t nn=0; nn<99999; ++nn) {
            isMCThere[nn]=0;
        }
        if (gEDBDEBUGLEVEL>3) cout << "INFO    Printing double counted MCEvt basetracks:" << endl;
        int maxEvt=0;
        int tmp=0;
        for (Int_t nn=0; nn<GLOBAL_InBTArray->GetEntries(); ++nn) {
            EdbSegP* seg=(EdbSegP*)GLOBAL_InBTArray->At(nn);
            nr=seg->MCEvt();
            if (nr>0)  {
                tmp=isMCThere[nr];
                ++tmp;
                isMCThere[nr]=tmp;
            }
            if (nr>maxEvt) maxEvt=nr;
            if (isMCThere[nr]>1)  if (gEDBDEBUGLEVEL>2) seg->PrintNice();
        }
        for (Int_t nn=1; nn<=maxEvt; ++nn) {
            if (isMCThere[nn]==0) {
                cout << " MC Event ---  " << nn << "  is not contained in InBTArray"<<endl;
            }
            if (isMCThere[nn]>1) {
                cout << "INFO   MC Event ---  " << nn << "  is :  " << isMCThere[nn] << " times contained in InBTArray"<<endl;
 
            }
        }
    }
 
 
 
    //--------------------------------------------------------
    // no need to fill these arrays if only reconstruction is done
    //--------------------------------------------------------
    if (cmd_OUTPUTLEVEL==1) return;
    //--------------------------------------------------------
 
 
 
 
 
 
    //--------------------------------------------------------
    // No need to fill these arrays anymore, since we have access to global event
    // information via the Brick.root G4 source file
    //--------------------------------------------------------
    cout << "------------------- No need to fill these arrays anymore, since we have access to global event  ------------------------"<<endl;
    cout << "------------------- information via the Brick.root G4 source file. Return Fill() function now. ------------------------"<<endl;
    return;
    //--------------------------------------------------------
 
 
 
 
 
 
 
 
    //--------------------------------------------------------
    // Fill the values for GLOBAL_EvtBT_xxxArray variables.
    //--------------------------------------------------------
    if (gEDBDEBUGLEVEL>=2) cout << "--- Fill the values for GLOBAL_EvtBT_xxxArray variables now..." <<endl;
 
    // Reset variables:
    for (Int_t nn=0; nn<99999; ++nn) {
        GLOBAL_EvtBT_FlagArray[nn]=-999;
        GLOBAL_EvtBT_MCArray[nn]=-1;
        GLOBAL_EvtBT_EArray[nn]=0;
        GLOBAL_EvtBT_TanThetaArray[nn]=-1;
        GLOBAL_EvtBT_ZArray[nn]=9999999;
    }
 
    if (gEDBDEBUGLEVEL>=2) cout << "--- GLOBAL_EvtBT_xxxArray reseted..." <<endl;
 
    npat = GLOBAL_gAli->Npatterns();
 
    EdbSegP* helpsegArr;
    EdbSegP* helpsegAll;
    Float_t helptx,helpty,helpP,helpZ;
 
    // Calculate Values for the very first plate the corresponding
    // basetrack appears in. Do only for MC Events....
    for (Int_t i=0; i<GLOBAL_InBTArray->GetEntries(); ++i) {
 
        if (GLOBAL_InBTArray->GetEntries()>99999-1) {
            cout << "WARNING: GLOBAL_InBTArray->GetEntries()>99999-1: Stop Filling...."<<endl;
            break;
        }
 
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout <<"--- Filling event: "<<Form("%4d",i)<< "\r\r\r\r" <<flush;
 
        helpsegArr=(EdbSegP*)GLOBAL_InBTArray->At(i);
        if (helpsegArr->MCEvt()<0) continue;
 
        // Loop over whole BrickVolume:
        for (Int_t nr2=npat-1; nr2>=middleplate; --nr2) {
            //for (Int_t nr2=npat-1; nr2>=0; --nr2) {
            for (Int_t nn=0; nn<GLOBAL_gAli->GetPattern(nr2)->GetN(); ++nn) {
 
                helpsegAll = GLOBAL_gAli->GetPattern(nr2)->GetSegment(nn);
                helptx=helpsegAll->TX();
                helpty=helpsegAll->TY();
                helpP=helpsegAll->P();
                helpZ=helpsegAll->Z();
 
                if (helpsegAll->MCEvt()==helpsegArr->MCEvt() &&helpsegAll->Flag()==helpsegArr->Flag()) {
                    //Now compare first P() and then Z():
                    if ( GLOBAL_EvtBT_EArray[i]>helpP ) continue;
                    if ( GLOBAL_EvtBT_ZArray[i]<helpZ ) continue;
                    //Now update values:
                    GLOBAL_EvtBT_EArray[i]=helpP;
                    GLOBAL_EvtBT_ZArray[i]=helpZ;
                    GLOBAL_EvtBT_MCArray[i]=helpsegAll->MCEvt();
                    GLOBAL_EvtBT_TanThetaArray[i]=TMath::Sqrt(helptx*helptx+helpty*helpty);
                    GLOBAL_EvtBT_FlagArray[i]=helpsegAll->Flag();
                }
            }
        }
    } // end of Calculate Values for the very first plate the corresponding
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
 
    if (gEDBDEBUGLEVEL>3) {
        cout << "Comparison:   GLOBAL_InBT_E     GLOBAL_InBT_E "<< endl;
        float ttheta;
        for (Int_t i=0; i<GLOBAL_InBTArray->GetEntries(); ++i) {
            helpsegArr=(EdbSegP*)GLOBAL_InBTArray->At(i);
            ttheta=TMath::Sqrt(helpsegArr->TX()*helpsegArr->TX()+helpsegArr->TY()*helpsegArr->TY());
            cout << "i =  " <<  i << "--------------------------------------------------"<<endl;
            cout << "MCEVT:   " << helpsegArr->MCEvt() << "    " << GLOBAL_EvtBT_MCArray[i] << endl;
            cout << "P:   " << helpsegArr->P() << "    " << GLOBAL_EvtBT_EArray[i] << endl;
            cout << "ttheta:   " << ttheta << "    " << GLOBAL_EvtBT_TanThetaArray[i] << endl;
            cout << "Flag:   " << helpsegArr->Flag() << "    " << GLOBAL_EvtBT_FlagArray[i] << endl;
            cout << "Z:   " << helpsegArr->Z() << "    " << GLOBAL_EvtBT_ZArray[i] << endl;
        }
    }
 
    return;
}

FillOutPutStructures()

void FillOutPutStructures

(

)

{
    if (cmd_OUTPUTLEVEL==1) return;
 
    Log(2, "ShowRec.cpp", "--- void FillOutPutStructures() ---");
 
    STREAM_ShowRecEff.open(STREAM_ShowRecEffName,ios::app);    // Fill Later, Open now :-)
    InitCutParameters();
 
    Int_t PARASETNR,INBTSHOWERNR;
    Double_t EvtBT_E,EvtBT_TanTheta;
    Int_t EvtBT_Flag,EvtBT_MC;
    Double_t InBT_E,InBT_TanTheta;
    Int_t InBT_Flag,InBT_MC;
    Int_t NBT,NBTMC,NBTallMC,NBTeMC;
    Double_t purall,pure;
    Double_t effall,effe;
    Double_t trckdens;
 
    TREE_ShowRecEff->SetBranchAddress("PARASETNR", &PARASETNR);
    TREE_ShowRecEff->SetBranchAddress("ShowerNr", &INBTSHOWERNR);
 
    TREE_ShowRecEff->SetBranchAddress("EvtBT_E", &EvtBT_E);
    TREE_ShowRecEff->SetBranchAddress("EvtBT_TanTheta", &EvtBT_TanTheta);
    TREE_ShowRecEff->SetBranchAddress("EvtBT_Flag", &EvtBT_Flag);
    TREE_ShowRecEff->SetBranchAddress("EvtBT_MC", &EvtBT_MC);
 
    TREE_ShowRecEff->SetBranchAddress("InBT_E", &InBT_E);
    TREE_ShowRecEff->SetBranchAddress("InBT_TanTheta", &InBT_TanTheta);
    TREE_ShowRecEff->SetBranchAddress("InBT_Flag", &InBT_Flag);
    TREE_ShowRecEff->SetBranchAddress("InBT_MC", &InBT_MC);
 
    TREE_ShowRecEff->SetBranchAddress("NBT", &NBT);
    TREE_ShowRecEff->SetBranchAddress("NBTMC", &NBTMC);
    TREE_ShowRecEff->SetBranchAddress("NBTallMC", &NBTallMC);
    TREE_ShowRecEff->SetBranchAddress("NBTeMC", &NBTeMC);
    TREE_ShowRecEff->SetBranchAddress("purall", &purall);
    TREE_ShowRecEff->SetBranchAddress("pure", &pure);
 
    TREE_ShowRecEff->SetBranchAddress("effall", &effall);
    TREE_ShowRecEff->SetBranchAddress("effe", &effe);
    TREE_ShowRecEff->SetBranchAddress("trckdens", &trckdens);
 
    for (int i=0; i<TREE_ShowRecEff->GetEntries(); ++i) {
 
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(i);
        TREE_ShowRecEff->GetEntry(i);
 
        STREAM_ShowRecEff <<  setw(10) << cmd_PADI;
        STREAM_ShowRecEff <<  setw(10) << cmd_BTPA;
        STREAM_ShowRecEff <<  setw(10) << cmd_BGTP;
        STREAM_ShowRecEff <<  setw(10) << cmd_ALTP;
        STREAM_ShowRecEff <<  setw(10) << cmd_FP;
        STREAM_ShowRecEff <<  setw(10) << cmd_MP;
        STREAM_ShowRecEff <<  setw(10) << cmd_LP;
        STREAM_ShowRecEff <<  setw(10) << cmd_NP;
 
        STREAM_ShowRecEff <<  setw(10) << cmd_LT;
        STREAM_ShowRecEff <<  setw(10) << cmd_MC;
 
        STREAM_ShowRecEff <<  setw(14) << PARASETNR;
        STREAM_ShowRecEff <<  setw(14) << INBTSHOWERNR;
 
        STREAM_ShowRecEff <<  setw(10) << EvtBT_E;
        STREAM_ShowRecEff <<  setw(14) << EvtBT_TanTheta;
        STREAM_ShowRecEff <<  setw(14) << EvtBT_Flag;
        STREAM_ShowRecEff <<  setw(10) << EvtBT_MC;
 
        STREAM_ShowRecEff <<  setw(10) << InBT_E;
        STREAM_ShowRecEff <<  setw(14) << InBT_TanTheta;
        STREAM_ShowRecEff <<  setw(14) << InBT_Flag;
        STREAM_ShowRecEff <<  setw(10) << InBT_MC;
 
        STREAM_ShowRecEff <<  setw(10) << NBT;
        STREAM_ShowRecEff <<  setw(10) << NBTallMC;
        STREAM_ShowRecEff <<  setw(10) << NBTeMC;
        STREAM_ShowRecEff <<  setw(10) << purall;
        STREAM_ShowRecEff <<  setw(10) << pure;
        STREAM_ShowRecEff <<  setw(10) << effall;
        STREAM_ShowRecEff <<  setw(10) << effe;
        STREAM_ShowRecEff <<  setw(10) << trckdens;
        STREAM_ShowRecEff << endl;
 
        // ---------
        NBTeMC_pure->Fill(pure,NBTeMC);
        NBTallMC_purall->Fill(purall,NBTallMC);
 
        NBTeMC_NBTMC->Fill(NBTallMC,NBTeMC);
        NBTeMC_NBT->Fill(NBT,NBTeMC);
 
        NBT_InBTE->Fill(InBT_E/1000.0,NBT);
        NBTeMC_InBTE->Fill(InBT_E/1000.0,NBTeMC);
 
        pure_InBTE->Fill(InBT_E/1000.0,pure);
        purall_InBTE->Fill(InBT_E/1000.0,purall);
        // ---------
        Hist_NBTeMC_pure->Fill(pure,NBTeMC);
        Hist_NBTallMC_purall->Fill(purall,NBTallMC);
 
        Hist_NBTeMC_NBTMC->Fill(NBTallMC,NBTeMC);
        Hist_NBTeMC_NBT->Fill(NBT,NBTeMC);
 
        Hist_NBT_InBTE->Fill(InBT_E/1000.0,NBT);
        Hist_NBTeMC_InBTE->Fill(InBT_E/1000.0,NBTeMC);
 
        Hist_pure_InBTE->Fill(InBT_E/1000.0,pure);
        Hist_purall_InBTE->Fill(InBT_E/1000.0,purall);
 
    }
 
    FILE_ShowRecEff->cd();
    TREE_ShowRecEff->Write();
 
    FILE_ShowRecHistos->cd();
    TCanvas* ShowRecEffPlots= new TCanvas("ShowRecEffPlots","ShowRecEffPlots",1200,1200);
    ShowRecEffPlots->Divide(2,4);
    ShowRecEffPlots->cd(1);
    NBTeMC_pure->Draw();
    ShowRecEffPlots->cd(2);
    NBTallMC_purall->Draw();
    ShowRecEffPlots->cd(3);
    NBTeMC_NBTMC->Draw();
    ShowRecEffPlots->cd(4);
    NBTeMC_NBT->Draw();
    ShowRecEffPlots->cd(5);
    NBT_InBTE->Draw();
    ShowRecEffPlots->cd(6);
    NBTeMC_InBTE->Draw();
    ShowRecEffPlots->cd(7);
    pure_InBTE->Draw();
    ShowRecEffPlots->cd(7);
    purall_InBTE->Draw();
    TCanvas* ShowRecEffPlots2= new TCanvas("ShowRecEffPlots2","ShowRecEffPlots2",1200,1200);
    ShowRecEffPlots2->Divide(2,4);
    ShowRecEffPlots2->cd(1);
    Hist_NBTeMC_pure->Draw("colz");
    ShowRecEffPlots2->cd(2);
    Hist_NBTallMC_purall->Draw("colz");
    ShowRecEffPlots2->cd(3);
    Hist_NBTeMC_NBTMC->Draw("colz");
    ShowRecEffPlots2->cd(4);
    Hist_NBTeMC_NBT->Draw("colz");
    ShowRecEffPlots2->cd(5);
    Hist_NBT_InBTE->Draw("colz");
    ShowRecEffPlots2->cd(6);
    Hist_NBTeMC_InBTE->Draw("colz");
    ShowRecEffPlots2->cd(7);
    Hist_pure_InBTE->Draw("colz");
    ShowRecEffPlots2->cd(8);
    Hist_purall_InBTE->Draw("colz");
 
    NBTeMC_pure->Write();
    NBTallMC_purall->Write();
    NBTeMC_NBTMC->Write();
    NBTeMC_NBT->Write();
    NBT_InBTE->Write();
    NBTeMC_InBTE->Write();
    Hist_NBTeMC_pure->Write();
    Hist_NBTallMC_purall->Write();
    Hist_NBTeMC_NBTMC->Write();
    Hist_NBTeMC_NBT->Write();
    Hist_NBT_InBTE->Write();
    Hist_NBTeMC_InBTE->Write();
    Hist_pure_InBTE->Write();
    Hist_purall_InBTE->Write();
 
    ShowRecEffPlots->Write();
    ShowRecEffPlots2->Write();
    return;
}

FillShowerAxis()

void FillShowerAxis

(

)

                         {
    cout << "IMPLEMENTED IN ... TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree ... CHECK THERE..."<<endl;
    return;
}

FindFollowingBTs()

Bool_t FindFollowingBTs	(	EdbSegP *	s1,
		EdbSegP *	s2,
		EdbPVRec *	gAli,
		TObjArray *	showersegarray
	)

if (dZ<30) continue; // Exclude the case of same Zpositions...

if (dZ<30) continue; // Exclude the case of same Zpositions...

{
    Log(4, "ShowRec.cpp", "--- Bool_t FindFollowingBTs() ---");
    cout << "WARNING::WARNING   Bool_t FindFollowingBTs() ...   IS NOT SUPPORTED ANYMORE. RETURN kFALSE now !!!"<<endl;
    return kFALSE;
 
    // ATTENTION NEW CUT CONDITION ITRODUCED...
    // SIGMA OF DTHETA CUT IS DEPENDING AN DIFERNECE TO INBT PLATE....
    // CUT_dtheta=1.5,2.0,2.5*CUT_dtheta_original
    int diff_pid=0;
    Float_t CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) <3) CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) >2) CUTFACTOR=1.5;
    if (TMath::Abs(InBT->PID()-s->PID()) >5) CUTFACTOR=2.0;
    //      cout << TMath::Abs(InBT->PID()-s->PID()) << "   " << CUTFACTOR << endl;
    //NORMAL:
    CUTFACTOR=1.0;
 
    EdbSegP* s_TestBT;
    EdbSegP* seg;
    Int_t nentries=showersegarray->GetEntries();
    Double_t dZ;
 
    // For the very first Z position we do not test
    // if testBT has Preceeders, only if it it has a BT around (case for e+e- coming from gammma):
    // Take 50microns and 80mrad in (dR/dT) around.
    // This does not affect the normal results, but helps for
    // events which may have a second BT close to InBT (like in e+e-)
    if (s->Z()==InBT->Z()) {
        //cout << "Test here..."<<endl;
        //cout << "GetdeltaTheta(s, InBT)= " << GetdeltaTheta(s, InBT) << endl;
        //cout << "GetdeltaRWithPropagation(s, InBT)= " << GetdeltaRWithPropagation(s, InBT) << endl;
        if (GetdeltaTheta(s, InBT) < 0.08 && GetdeltaRWithPropagation(s, InBT) < 50.0) {
            return kTRUE;
        }
        //cout << "Test here...done. Not fullfilled condition."<<endl;
    }
 
 
    // it is true to use  local_gAli  since this is given over in the function head as local_gAli  ...
    Int_t local_gAli_npat=local_gAli->Npatterns();
    //if (gEDBDEBUGLEVEL>2)
    //  cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
    // Loop over all plates of local_gAli, since this is already
    // extracted with the right numbers of plates...
    for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
        //cout << local_gAli->GetPattern(patterloop_cnt)->Z() <<  "   " <<  InBT->Z() << endl;
        if (local_gAli->GetPattern(patterloop_cnt)->Z()<InBT->Z()) continue;
        if (TMath::Abs(local_gAli->GetPattern(patterloop_cnt)->Z()-s->Z())>4.0*1300.0+50.0) continue;// Exclude the case of more than 4 plates after..
 
        for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
            s_TestBT = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
            if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
 
            dZ=TMath::Abs(s_TestBT->Z()-s->Z());
            if (dZ<0.1&&TMath::Abs(s_TestBT->X()-s->X())<1.0) continue;         // Exclude the case of same Basetracks:
            if (dZ>(4*1300.0)+30.0) continue;     // Exclude the case of more than 4 plates after...
 
 
            if (GetdeltaThetaSingleAngles(s, s_TestBT) > CUTFACTOR*CUT_PARAMETER[3] ) continue;
            if (GetdeltaRWithPropagation(s, s_TestBT) > CUT_PARAMETER[2]) continue;
            return kTRUE;
        }
 
    }
 
    //---------------------------------------------
    return kFALSE;
}

FindPrecedingBTs()

Bool_t FindPrecedingBTs	(	EdbSegP *	s1,
		EdbSegP *	s2,
		EdbPVRec *	gAli,
		TObjArray *	showersegarray
	)

{
    Log(4, "ShowRec.cpp", "--- Bool_t FindPrecedingBTs() ---");
 
    int diff_pid=0;
    Float_t CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) <3) CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) >2) CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) >5) CUTFACTOR=2.0;
 
    EdbSegP* s_TestBT;
    Int_t nentries=showersegarray->GetEntries();
    Double_t dZ;
 
    // Dont check the BT before the InBT position:
    if (s->Z()<InBT->Z()) {
        return kFALSE;
    }
 
    // For the very first Z position we do not test
    // if testBT has Preceeders, only if it it has a BT around (case for e+e- coming from gammma):
    // Take 50microns and 80mrad in (dR/dT) around.
    // This does not affect the normal results, but helps for
    // events which may have a second BT close to InBT (like in e+e-)
    if (s->Z()==InBT->Z()) {
        //cout << "Test here..."<<endl;
        //cout << "GetdeltaTheta(s, InBT)= " << GetdeltaTheta(s, InBT) << endl;
        //cout << "GetdeltaRWithPropagation(s, InBT)= " << GetdeltaRWithPropagation(s, InBT) << endl;
        if (GetdeltaTheta(s, InBT) < 0.08 && GetdeltaRWithPropagation(s, InBT) < 50.0) {
            return kTRUE;
        }
        //cout << "Test here...done. Not fullfilled condition."<<endl;
    }
 
    for (Int_t i=nentries-1; i>=0; --i) {
        s_TestBT = (EdbSegP*)( showersegarray->At(i) );
 
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Do   "<< s_TestBT->ID() << " " <<  s_TestBT->PID() << " " << s_TestBT->MCEvt() <<"  " << s_TestBT->Z() << endl;
 
        dZ=TMath::Abs(s_TestBT->Z()-s->Z());
        if (dZ<30) continue;                  // Exclude the case of same Zpositions...
        if (dZ>(3*1300.0)+30.0) continue;     // Exclude the case of more than 4 plates before...
 
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Checking dT,dR and dZ for i:  " << i << "  " << GetdeltaTheta(s, s_TestBT)  << "  " << GetdeltaRWithPropagation(s, s_TestBT) << "  "<<dZ << endl;
 
        if (GetdeltaTheta(s, s_TestBT) > CUTFACTOR*CUT_PARAMETER[3] ) continue;
        if (GetdeltaRWithPropagation(s, s_TestBT) > CUT_PARAMETER[2]) continue;
 
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Checking dT,dR and dZ for i:  " << i << "  " << GetdeltaTheta(s, s_TestBT)  << "  " << GetdeltaRWithPropagation(s, s_TestBT) << "  "<<dZ << "   ok!"<<endl;
        return kTRUE;
    }
    //---------------------------------------------
    return kFALSE;
}

FindPrecedingBTs_local_gAli()

Bool_t FindPrecedingBTs_local_gAli	(	EdbSegP *	s1,
		EdbSegP *	s2,
		EdbPVRec *	gAli,
		TObjArray *	showersegarray
	)

{
    Log(4, "ShowRec.cpp", "--- Bool_t FindPrecedingBTs_local_gAli() ---");
 
    int diff_pid=0;
    Float_t CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) <3) CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) >2) CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) >5) CUTFACTOR=2.0;
 
    EdbSegP* s_TestBT;
    EdbSegP* seg;
    Int_t nentries=showersegarray->GetEntries();
    Double_t dZ;
 
 
    // Dont check the BT before the InBT position:
    if (s->Z()<InBT->Z()) {
        return kFALSE;
    }
 
    // For the very first Z position we do not test
    // if testBT has Preceeders, only if it it has a BT around (case for e+e- coming from gammma):
    // Take 50microns and 80mrad in (dR/dT) around.
    // This does not affect the normal results, but helps for
    // events which may have a second BT close to InBT (like in e+e-)
    if (s->Z()==InBT->Z()) {
        //cout << "Test here..."<<endl;
        //cout << "GetdeltaThetaSingleAngles(s, InBT)= " << GetdeltaThetaSingleAngles(s, InBT) << endl;
        //cout << "GetdeltaRWithPropagation(s, InBT)= " << GetdeltaRWithPropagation(s, InBT) << endl;
        if (GetdeltaThetaSingleAngles(s, InBT) < 0.08 && GetdeltaRWithPropagation(s, InBT) < 50.0) {
            return kTRUE;
        }
        //cout << "Test here...done. Not fullfilled condition."<<endl;
    }
 
 
    // it is true to use  local_gAli  since this is given over in the function head as local_gAli  ...
    Int_t local_gAli_npat=local_gAli->Npatterns();
    //if (gEDBDEBUGLEVEL>2)
    //  cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
    // Loop over all plates of local_gAli, since this is already
    // extracted with the right numbers of plates...
    for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
        //cout << local_gAli->GetPattern(patterloop_cnt)->Z() <<  "   " <<  InBT->Z() << endl;
        if (local_gAli->GetPattern(patterloop_cnt)->Z()<InBT->Z()) continue;
        if (TMath::Abs(local_gAli->GetPattern(patterloop_cnt)->Z()-s->Z())>3.0*1300.0+50.0) continue;// Exclude the case of more than 4 plates after/before..
 
        for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
            s_TestBT = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
            if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
 
            dZ=TMath::Abs(s_TestBT->Z()-s->Z());
 
            // test only BTs which have LOWER Z (so they are before)....
            if (s_TestBT->Z()-s->Z()>=0) continue;
 
            if (dZ<30) continue;                  // Exclude the case of same Zpositions...
            if (dZ<0.1&&TMath::Abs(s_TestBT->X()-s->X())<1.0) continue;         // Exclude the case of same Basetracks:
 
            // but why not search in both directions foreward and afterward ???
            if (dZ>(3.0*1300.0+30.0)) continue;     // Exclude the case of more than 4 plates after...
 
            if (GetdeltaThetaSingleAngles(s, s_TestBT) > CUTFACTOR*CUT_PARAMETER[3] ) continue;
            if (GetdeltaRWithPropagation(s, s_TestBT) > CUT_PARAMETER[2]) continue;
            return kTRUE;
        }
 
    }
 
    //---------------------------------------------
    return kFALSE;
}

FindPrecedingBTsSingleThetaAngle()

Bool_t FindPrecedingBTsSingleThetaAngle	(	EdbSegP *	s1,
		EdbSegP *	s2,
		EdbPVRec *	gAli,
		TObjArray *	showersegarray
	)

11.06.2010: New including case:

11.06.2010: New including case:

{
    Log(4, "ShowRec.cpp", "--- Bool_t FindPrecedingBTsSingleThetaAngle() ---");
 
    int diff_pid=0;
    Float_t CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) <3) CUTFACTOR=1.0;
    if (TMath::Abs(InBT->PID()-s->PID()) >2) CUTFACTOR=1.0;
 
    EdbSegP* s_TestBT;
    Int_t nentries=showersegarray->GetEntries();
    Double_t dZ;
 
    // Dont check the BT before the InBT position:
    if (s->Z()<InBT->Z()) {
        return kFALSE;
    }
 
    // For the very first Z position we do not test
    // if testBT has Preceeders, only if it it has a BT around (case for e+e- coming from gammma):
    // Take 50microns and 80mrad in (dR/dT) around.
    // This does not affect the normal results, but helps for
    // events which may have a second BT close to InBT (like in e+e-)
    if (s->Z()==InBT->Z()) {
        /*
          cout << "Bool_t FindPrecedingBTsSingleThetaAngle(EdbSegP* s, EdbSegP* InBT, EdbPVRec *gAli, TObjArray* showersegarray)" << endl;
          cout << "Test here... for s ( " << s << " ) and InBT ( " << InBT << " ) :" <<   endl;
        s->PrintNice();
        InBT->PrintNice();
               cout << "GetdeltaThetaSingleAngles(s, InBT)= " << GetdeltaThetaSingleAngles(s, InBT) << endl;
               cout << "GetdeltaRWithPropagation(s, InBT)= " << GetdeltaRWithPropagation(s, InBT) << endl;
        */
        if (GetdeltaThetaSingleAngles(s, InBT) < 0.08 && GetdeltaRWithPropagation(s, InBT) < 50.0) {
            return kTRUE;
        }
        //cout << "Test here...done. Not fullfilled condition."<<endl;
    }
 
 
    Float_t nmaxholes=3.0;
    if (CUT_PARAMETER[4]==3) nmaxholes=3.0;
    if (CUT_PARAMETER[4]==5) nmaxholes=5.0;
    if (CUT_PARAMETER[4]==9) nmaxholes=9.0;
//      cout << "DEBUG    CUT_PARAMETER[4] = "  << CUT_PARAMETER[4] << endl;
//      cout << "DEBUG    nmaxholes = "  << nmaxholes << endl;
 
    for (Int_t i=nentries-1; i>=0; --i) {
        s_TestBT = (EdbSegP*)( showersegarray->At(i) );
 
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Do   "<< s_TestBT->ID() << " " <<  s_TestBT->PID() << " " << s_TestBT->MCEvt() <<"  " << s_TestBT->Z() << endl;
 
        dZ=TMath::Abs(s_TestBT->Z()-s->Z());
        if (dZ<30) continue;                  // Exclude the case of same Zpositions...
        if (dZ>(nmaxholes*1300.0)+30.0) continue;     // Exclude the case of more than 4 plates before...
 
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Checking dT,dR and dZ for i:  " << i << "  " << GetdeltaThetaSingleAngles(s, s_TestBT)  << "  " << GetdeltaRWithPropagation(s, s_TestBT) << "  "<<dZ << endl;
 
        if (GetdeltaThetaSingleAngles(s, s_TestBT) > CUTFACTOR*CUT_PARAMETER[3] ) continue;
        if (GetdeltaRWithPropagation(s, s_TestBT) > CUT_PARAMETER[2]) continue;
 
        if (gEDBDEBUGLEVEL>3) {
            cout << "--- --- Checking dT,dR and dZ for i:  " << i << "  " << GetdeltaThetaSingleAngles(s, s_TestBT)  << "  " << GetdeltaRWithPropagation(s, s_TestBT) << "  "<<dZ << ".  ok! Print segment to check and the shower segment which maches:"<<endl;
            s->PrintNice();
            s_TestBT->PrintNice();
        }
        return kTRUE;
    }
    //---------------------------------------------
 
    return kFALSE;
}

FindPrecedingBTsSingleThetaAngleTCDEBUG()

Bool_t FindPrecedingBTsSingleThetaAngleTCDEBUG	(	EdbSegP *	s1,
		EdbSegP *	s2,
		EdbPVRec *	gAli,
		TObjArray *	showersegarray
	)

{
    Log(4, "ShowRec.cpp", "--- Bool_t FindPrecedingBTsSingleThetaAngleTCDEBUG() ---");
 
    Float_t CUTFACTOR=1.0;
 
    EdbSegP* s_TestBT;
    Int_t nentries=showersegarray->GetEntries();
    Double_t dZ;
 
    // Dont check the BT before the InBT position:
    if (s->Z()<InBT->Z()) {
        return kFALSE;
    }
 
 
 
    // For the very first Z position we do not test
    // if testBT has Preceeders, only if it it has a BT around (case for e+e- coming from gammma):
    // Take 50microns and 80mrad in (dR/dT) around.
    // This does not affect the normal results, but helps for
    // events which may have a second BT close to InBT (like in e+e-)
    if (TMath::Abs(s->Z()-InBT->Z())<5.0) {
        //cout << "Test here..."<<endl;
        //cout << "GetdeltaThetaSingleAngles(s, InBT)= " << GetdeltaThetaSingleAngles(s, InBT) << endl;
        //cout << "GetdeltaRWithPropagation(s, InBT)= " << GetdeltaRWithPropagation(s, InBT) << endl;
        if (GetdeltaThetaSingleAngles(s, InBT) < 0.08 && GetdeltaRWithPropagation(s, InBT) < 50.0) {
            return kTRUE;
        }
 
 
        //cout << "Test here...done. Not fullfilled condition."<<endl;
    }
 
 
    for (Int_t i=nentries-1; i>=0; --i) {
        s_TestBT = (EdbSegP*)( showersegarray->At(i) );
 
        // cout << "--- --- FindPrecedingBTsSingleThetaAngleTCDEBUG  Do   "<< s_TestBT->ID() << " " <<  s_TestBT->PID() << " " << s_TestBT->MCEvt() <<"  " << s_TestBT->Z() << endl;
 
        dZ=TMath::Abs(s_TestBT->Z()-s->Z());
        if (dZ<30) continue;                  // Exclude the case of same Zpositions...
        if (dZ>(3*1300.0)+30.0) continue;     // Exclude the case of more than 4 plates before...
 
        Float_t interim_dT=GetdeltaThetaSingleAngles(s, s_TestBT);
        Float_t interim_dRProp=GetdeltaRWithPropagation(s, s_TestBT);
 
        // cout << "--- --- FindPrecedingBTsSingleThetaAngleTCDEBUG  Checking dT,dR and dZ for i:  " << i << "  " << interim_dT << "  " << interim_dRProp << "  "<<dZ << endl;
 
        if (GetdeltaThetaSingleAngles(s, s_TestBT) > CUTFACTOR*CUT_PARAMETER[3] ) continue;
        if (GetdeltaRWithPropagation(s, s_TestBT) > CUT_PARAMETER[2]) continue;
 
        // cout << "--- --- Checking dT,dR and dZ:    ok!"<<endl;
        return kTRUE;
    }
    //---------------------------------------------
 
    return kFALSE;
}

Get_NN_ALG_MLP()

void Get_NN_ALG_MLP	(	TTree *	inputtree,
		Int_t	parasetnr
	)

{
    if (!gROOT->GetClass("TMultiLayerPerceptron")) {
        gSystem->Load("libMLP");
    }
 
//-----------------------------------------------------------------------------
//-
//-
//-    WE USE FOR NN_ALG and the PARAMETERSETS For it the following conventions:
//-
//-    NCUTSteps =   20;
//-    MLP Structure:
//-
//-    a)  Paraset [0..20[
//-           first five variables.
//-    b)  Paraset [20..40[
//-           first ten variables.
//-    c)  Paraset [40..60[
//-           all (30) variables.
//-    d)  ....(something else)
//-
//-    As Trainingssample we use EXP2500 Events, Padi 199 ... 196 with b11845 BG
//-    additionally as BG samples b99999GENERICBG  and b99998GENERICBG
//-    (both with no signal...)
//-
//-
//-    Take care thet the added Traingssample has about the same traingssampledata for BG and SG
//-
//-----------------------------------------------------------------------------
 
// Define NN_ALG charactereistic variables:
    Float_t dT_InBT_To_TestBT=0;
    Float_t dR_InBT_To_TestBT=0;
    Float_t dR_TestBT_To_InBT=0;
    Float_t zDist_TestBT_To_InBT=0;
    Float_t SpatialDist_TestBT_To_InBT=0;
    Float_t zDiff_TestBT_To_InBT=0;
    Float_t dT_NextBT_To_TestBT=0;
    Float_t dR_NextBT_To_TestBT=0;
    Float_t mean_dT_2before=0;
    Float_t mean_dR_2before=0;
    Float_t  mean_dT_before=0;
    Float_t mean_dR_before=0;
    Float_t  mean_dT_same=0;
    Float_t mean_dR_same=0;
    Float_t  mean_dT_after=0;
    Float_t mean_dR_after=0;
    Float_t  mean_dT_2after=0;
    Float_t  mean_dR_2after=0;
 
    Float_t min_dT_2before=0;
    Float_t min_dR_2before=0;
    Float_t  min_dT_before=0;
    Float_t min_dR_before=0;
    Float_t  min_dT_same=0;
    Float_t min_dR_same=0;
    Float_t  min_dT_after=0;
    Float_t min_dR_after=0;
    Float_t  min_dT_2after=0;
    Float_t  min_dR_2after=0;
    Int_t nseg_1before=0;
    Int_t nseg_2before=0;
    Int_t nseg_3before=0;
    Int_t nseg_1after=0;
    Int_t nseg_2after=0;
    Int_t nseg_3after=0;
    Int_t nseg_same=0;
    Int_t type;
 
    TString layout="";
 
    int ann_inputneurons=CUT_PARAMETER[1];
 
    if (ann_inputneurons==5) {
        layout="@dT_InBT_To_TestBT,@dR_InBT_To_TestBT,@dR_TestBT_To_InBT,@zDiff_TestBT_To_InBT,@SpatialDist_TestBT_To_InBT:6:5:type";
    }
    if (ann_inputneurons==10) {
        layout="@dT_InBT_To_TestBT,@dR_InBT_To_TestBT,@dR_TestBT_To_InBT,@zDiff_TestBT_To_InBT,SpatialDist_TestBT_To_InBT,nseg_2before,nseg_1before,nseg_same,nseg_1after,nseg_2after:11:10:type";
    }
    if (ann_inputneurons==20) {
        layout="@dT_InBT_To_TestBT,@dR_InBT_To_TestBT,@dR_TestBT_To_InBT,@zDiff_TestBT_To_InBT,SpatialDist_TestBT_To_InBT,nseg_2before,nseg_1before,nseg_same,nseg_1after,nseg_2after,mean_dT_2before,mean_dT_before,mean_dT_same,mean_dT_after,mean_dT_2after,mean_dR_2before,mean_dR_before,mean_dR_same,mean_dR_after,mean_dR_2after:21:20:type";
    }
    if (ann_inputneurons==30) {
        layout="@dT_InBT_To_TestBT,@dR_InBT_To_TestBT,@dR_TestBT_To_InBT,@zDiff_TestBT_To_InBT,SpatialDist_TestBT_To_InBT,nseg_2before,nseg_1before,nseg_same,nseg_1after,nseg_2after,mean_dT_2before,mean_dT_before,mean_dT_same,mean_dT_after,mean_dT_2after,mean_dR_2before,mean_dR_before,mean_dR_same,mean_dR_after,mean_dR_2after,min_dT_2before,min_dT_before,min_dT_same,min_dT_after,min_dT_2after,min_dR_2before,min_dR_before,min_dR_same,min_dR_after,min_dR_2after:31:30:type";
    }
 
    cout << "ann_inputneurons:   " << ann_inputneurons << endl;
    cout << "Layout of ANN:   " << layout << endl;
 
// Create the network:
    TMlpANN = new TMultiLayerPerceptron(layout,simu,"(Entry$)%2","(Entry$+1)%2");
 
    return;
}

GetConeOrTubeDistanceToBTOfShowerArray()

Bool_t GetConeOrTubeDistanceToBTOfShowerArray	(	EdbSegP *	sa,
		EdbSegP *	InBT,
		TObjArray *	showersegarray,
		Double_t	CylinderRadius,
		Double_t	ConeAngle
	)

{
 
    Bool_t isTrueForBT=kFALSE;
    Int_t lastI=0;
    Double_t factor=1.0;
 
    EdbSegP* s_TestBT;
    Int_t nentries=showersegarray->GetEntries();
    //cout << "nentries=showersegarray->GetEntries(); "  <<  nentries << endl;
 
    // Now call GetConeOrTubeDistanceToInBT for every BT which was reconstructed up to now in the shower:
    for (Int_t i=0; i<nentries; i++) {
        s_TestBT = (EdbSegP*)( showersegarray->At(i) );
        // Dont check the BT which is before or same Z as the BaseTrack(i) position:
        // But ---not--- for the first Basetrack. There we allow it!
        //if (s_TestBT->Z()>=sa->Z() && i>0) continue;
        if (s_TestBT->Z()>sa->Z() ) continue;
 
        lastI=i;
 
        if (i==0) {
            factor=1.0;
        }
        else {
            factor=3.0;
        }
 
 
        if (GetConeOrTubeDistanceToInBT(sa, s_TestBT, factor*CylinderRadius, factor*ConeAngle)==kTRUE) {
            isTrueForBT=kTRUE;
            break;
        }
 
        //if (i>0) cout << "GetConeOrTubeDistanceToBTOfShowerArray::  i="<<i<<endl;
 
    }
 
 
    if (isTrueForBT) {
        //if (lastI>0) cout <<"for i= " << lastI<< " return true with factor "<< factor << endl;
        return kTRUE;
    }
 
    return kFALSE;
}

GetConeOrTubeDistanceToInBT()

Bool_t GetConeOrTubeDistanceToInBT	(	EdbSegP *	sa,
		EdbSegP *	s,
		Double_t	ConeAngle,
		Double_t	CylinderRadius
	)

Outside if angle greater than ConeAngle (to be fulfilled for Cone and Tube in both cases)

if angle smaller than ConeAngle, then you can differ between Tuberadius and CylinderRadius

Outside if angle greater than ConeAngle (to be fulfilled for Cone and Tube in both cases)

if angle smaller than ConeAngle, then you can differ between Tuberadius and CylinderRadius

{
    Log(4,"ShowRec.cpp", "--- Bool_t GetConeOrTubeDistanceToInBT() ---");
 
    TVector3 x1(InBT->X(),InBT->Y(),InBT->Z());
    TVector3 x2(sa->X(),sa->Y(),sa->Z());
    TVector3 direction_x1(InBT->TX()*1300,InBT->TY()*1300,1300);
    TVector3 direction_x2(sa->TX()*1300,sa->TY()*1300,1300);
    TVector3 u1=x2-x1;
 
    Double_t direction_x1_norm= direction_x1.Mag();
    Double_t cosangle=  (direction_x1*u1)/(u1.Mag()*direction_x1_norm);
    Double_t angle = TMath::ACos(cosangle);
    // NO THIS IS NOT THE CONE ANGLE!!
 
    TVector3 direction_1(InBT->TX()*1300,InBT->TY()*1300,1300);
    TVector3 direction_2(sa->TX()*1300,sa->TY()*1300,1300);
 
    /*
    cout <<"------"<<endl;
    cout << "angle =  " << angle << endl;
    cout << "angle V2 =  " << x1.Angle(x2) << endl;
    cout << "angle V3 =  " << direction_x1.Angle(direction_x2) << endl;
    cout << "angle V4 =  " << direction_1.Angle(direction_2) << "   " <<  direction_1.Angle(direction_2)/3.14*180.0 << endl;
 
    cout << "angle V5   direction_x1.Angle(u1  =  " << direction_x1.Angle(u1) << endl;
    cout << "angle V5   u1.Angle(direction_x1  =  " << u1.Angle(direction_x1) << endl;
    */
    angle=u1.Angle(direction_x1);
 
 
    // For the case where the two basetracks have same z position
    // the angle is about 90 degree so it makes no sense to calculate it...
    // therefore we set it artificially to zero:
    if (TMath::Abs(InBT->Z()-sa->Z())<5.0 ) {
        angle=0.0;
        //if (gEDBDEBUGLEVEL>3) //cout << "same z position, set angle artificially to zero" << endl;
    }
 
    //   cout << "--- Bool_t GetConeOrTubeDistanceToInBT() ---"<<endl;
    //  InBT->PrintNice();
    //  sa->PrintNice();
    //  cout << "angle= " <<  angle << "  ConeAngle= " << ConeAngle << endl;
 
 
    // If this InBT is in z position AFTER the testBT, the cone goes in the other direction and therefore, we have
    // to mirror the angle by 180 degree:
    if (angle>TMath::Pi()/2.0) {
        angle=TMath::Abs(TMath::Pi()-angle);
        //cout << "reverse angle: " << angle << endl;
    }
 
    if (angle>ConeAngle) {
        return kFALSE;
    }
 
    Double_t TubeDistance = 1.0/direction_x1_norm  *  ( (x2-x1).Cross(direction_x1) ).Mag();
    //  cout << "CylinderRadius= " <<  CylinderRadius << "  TubeDistance= " << TubeDistance << endl;
    if (TubeDistance>CylinderRadius) {
        return kFALSE;
    }
 
    return kTRUE;
}

GetdeltaRNoPropagation()

Double_t GetdeltaRNoPropagation	(	EdbSegP *	s,
		EdbSegP *	stest
	)

{
    Log(4, "ShowRec.cpp", "--- Bool_t GetdeltaRNoPropagation() ---");
    return TMath::Sqrt((s->X()-stest->X())*(s->X()-stest->X())+(s->Y()-stest->Y())*(s->Y()-stest->Y()));
}

GetdeltaRWithPropagation()

Double_t GetdeltaRWithPropagation	(	EdbSegP *	s1,
		EdbSegP *	s2
	)

{
    Log(4, "ShowRec.cpp", "--- Bool_t GetdeltaRWithPropagation() ---");
    // Propagate s to z-position of stest:
    Double_t zorig;
    Double_t dR;
    zorig=s->Z();
    s->PropagateTo(stest->Z());
    dR=(s->X()-stest->X())*(s->X()-stest->X())+(s->Y()-stest->Y())*(s->Y()-stest->Y());
    dR=TMath::Sqrt(dR);
    s->PropagateTo(zorig);
    return dR;
}

GetdeltaTheta()

Double_t GetdeltaTheta	(	EdbSegP *	s1,
		EdbSegP *	s2
	)

{
    Log(4, "ShowRec.cpp", "--- Bool_t GetdeltaTheta() ---");
 
    Double_t tx1,tx2,ty1,ty2;
    tx1=s1->TX();
    tx2=s2->TX();
    ty1=s1->TY();
    ty2=s2->TY();
    //   Double_t dt= TMath::Sqrt(tx1*tx1+ty1*ty1) - TMath::Sqrt(tx2*tx2+ty2*ty2); // version which was used for all studies up to now...
    //Double_t dt= TMath::Sqrt( (tx1-tx2)*(tx1-tx2) + (ty1-ty2)*(ty1-ty2) ); // new version to test... => implemented in GetdeltaThetaSingleAngles
    Double_t dt= TMath::Abs(TMath::Sqrt(tx1*tx1+ty1*ty1) - TMath::Sqrt(tx2*tx2+ty2*ty2)); // version which was used for all studies up to now...  NOW mit abs()
    return dt;
}

GetdeltaThetaSingleAngles()

Double_t GetdeltaThetaSingleAngles	(	EdbSegP *	s1,
		EdbSegP *	s2
	)

{
    Log(4, "ShowRec.cpp", "--- Bool_t GetdeltaThetaSingleAngles() ---");
 
    Double_t tx1,tx2,ty1,ty2;
    tx1=s1->TX();
    tx2=s2->TX();
    ty1=s1->TY();
    ty2=s2->TY();
    //Double_t dt= TMath::Sqrt(tx1*tx1+ty1*ty1) - TMath::Sqrt(tx2*tx2+ty2*ty2); // version which was used for all studies up to now...
    Double_t dt= TMath::Sqrt( (tx1-tx2)*(tx1-tx2) + (ty1-ty2)*(ty1-ty2) ); // new version to test...
    return dt;
}

GetdMinDist()

Double_t GetdMinDist ( EdbSegP *  s1, EdbSegP *  s2  )

inline

                                                     {
    return GetMinimumDist(s1,s2);
}

GetdR()

Double_t GetdR ( EdbSegP *  s1, EdbSegP *  s2  )

inline

                                               {
    return GetdeltaRWithPropagation(s1,s2);
}

GetdT()

Double_t GetdT ( EdbSegP *  s1, EdbSegP *  s2  )

inline

                                               {
    return GetdeltaTheta(s1,s2);
}

GetEvent_ParasetDefinitionTree()

void GetEvent_ParasetDefinitionTree

(

Int_t

nr

)

{
    Log(2, "ShowRec.cpp", "--- void GetEvent_ParasetDefinitionTree() ---");
 
    Double_t dr_max,dt_max,coneangle,tubedist;
    Int_t nholes_max;
    Double_t ann_output;
    Int_t ann_inputneurons;
    Double_t distMin_max;
    Int_t tracksegs_max;
    Double_t distMin_dt_max;
    Double_t cut_back_dmin,cut_for_dmin,cut_back_dtheta,cut_for_dtheta,cut_back_dr,cut_for_dr,cut_back_dz,cut_for_dz;
    // ALTP 10:  GS from libShowRec
    Double_t cut_gs_cut_dip=150;
    Double_t cut_gs_cut_dmin=40;
    Double_t cut_gs_cut_dr=60;
    Double_t cut_gs_cut_dz=19000;
    Double_t cut_gs_cut_dtheta=0.06;
    Double_t cut_gs_cut_piddiff=1;
    Int_t cut_gs_cut_oppositeflag=0;
 
    if              (cmd_ALTP==0) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
        TREE_ParaSetDefinitions->GetEntry(nr);
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
        TREE_ParaSetDefinitions->Show(nr);
        CUT_PARAMETER[0]=tubedist;
        CUT_PARAMETER[1]=coneangle;
        CUT_PARAMETER[2]=dr_max;
        CUT_PARAMETER[3]=dt_max;
    }
    else if     (cmd_ALTP==1) {
        cout << "TODO"<<endl;
    }
    else if     (cmd_ALTP==2) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
        TREE_ParaSetDefinitions->GetEntry(nr);
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
        TREE_ParaSetDefinitions->Show(nr);
        CUT_PARAMETER[0]=tubedist;
        CUT_PARAMETER[1]=coneangle;
        CUT_PARAMETER[2]=dr_max;
        CUT_PARAMETER[3]=dt_max;
 
    }
    else if     (cmd_ALTP==3) {
        TREE_ParaSetDefinitions->Print();
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ANN_OUTPUT",&ann_output);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_ANN_INPUTNEURONS",&ann_inputneurons);
 
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
 
        TREE_ParaSetDefinitions->GetEntry(0);
        CUT_PARAMETER[0]=ann_output;
        CUT_PARAMETER[1]=ann_inputneurons;
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
        cout << "TODO"<<endl;
    }
    else if     (cmd_ALTP==4) {
        cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0)   cmd_ALTP==4 "<<endl;
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_NHOLES_MAX",&nholes_max);
 
        TREE_ParaSetDefinitions->GetEntry(nr);
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
        TREE_ParaSetDefinitions->Show(nr);
        CUT_PARAMETER[0]=tubedist;
        CUT_PARAMETER[1]=coneangle;
        CUT_PARAMETER[2]=dr_max;
        CUT_PARAMETER[3]=dt_max;
        CUT_PARAMETER[4]=nholes_max;
 
 
    }
 
    else if     (cmd_ALTP==5) {
        Double_t  CUT_P;                        // s->P()
        Double_t  CUT_ALISUBSIZE;               // eAli_local_half_size
        cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0)   cmd_ALTP==5 "<<endl;
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_P",&CUT_P);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ALISUBSIZE",&CUT_ALISUBSIZE);
        TREE_ParaSetDefinitions->GetEntry(nr);
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
 
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
        TREE_ParaSetDefinitions->Show(nr);
        CUT_PARAMETER[0]=CUT_P;
        CUT_PARAMETER[1]=CUT_ALISUBSIZE;
 
    }
 
 
    else if   (cmd_ALTP==6) {
        cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0)   cmd_ALTP==6 "<<endl;
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_TRACKATTACH_DISTMIN",&distMin_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_TRACKATTACH_DTAN_MAX",&distMin_dt_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_TRACKATTACH_NTRACKSEG",&tracksegs_max);
        TREE_ParaSetDefinitions->GetEntry(nr);
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
 
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
        TREE_ParaSetDefinitions->Show(nr);
        CUT_PARAMETER[0]=tubedist;
        CUT_PARAMETER[1]=coneangle;
        CUT_PARAMETER[2]=dr_max;
        CUT_PARAMETER[3]=dt_max;
 
        CUT_PARAMETER[4]=distMin_max;
        CUT_PARAMETER[5]=distMin_dt_max;
        CUT_PARAMETER[6]=tracksegs_max;
    }
 
 
    else if   (cmd_ALTP==7||cmd_ALTP==9) {
        cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0)   cmd_ALTP==7 "<<endl;
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
        TREE_ParaSetDefinitions->GetEntry(nr);
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
        TREE_ParaSetDefinitions->Show(nr);
        CUT_PARAMETER[0]=tubedist;
        CUT_PARAMETER[1]=coneangle;
        CUT_PARAMETER[2]=dr_max;
        CUT_PARAMETER[3]=dt_max;
    }
 
 
    else if   (cmd_ALTP==8) {
        cout << "--- Get TREE_ParaSetDefinitions->GetEntry(0)   cmd_ALTP==8 "<<endl;
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_BACK_DMIN",&cut_back_dmin);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_BACK_DTHETA",&cut_back_dtheta);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_BACK_DR",&cut_back_dr);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_BACK_DZ",&cut_back_dz);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_FOR_DMIN",&cut_for_dmin);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_FOR_DTHETA",&cut_for_dtheta);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_FOR_DR",&cut_for_dr);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_FOR_DZ",&cut_for_dz);
        TREE_ParaSetDefinitions->GetEntry(nr);
        cout << TREE_ParaSetDefinitions->GetEntries() << endl;
        cout << "GAGA    nr = " << nr << endl;
 
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
        TREE_ParaSetDefinitions->Show(nr);
        CUT_PARAMETER[0]=cut_back_dmin;
        CUT_PARAMETER[1]=cut_back_dtheta;
        CUT_PARAMETER[2]=cut_back_dr;
        CUT_PARAMETER[3]=cut_back_dz;
        CUT_PARAMETER[4]=cut_for_dmin;
        CUT_PARAMETER[5]=cut_for_dtheta;
        CUT_PARAMETER[6]=cut_for_dr;
        CUT_PARAMETER[7]=cut_for_dz;
    }
 
    else if   (cmd_ALTP==10) {
        cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0)   cmd_ALTP==10 "<<endl;
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DIP",&cut_gs_cut_dip);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DMIN",&cut_gs_cut_dmin);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DR",&cut_gs_cut_dr);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DZ",&cut_gs_cut_dz);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DTHETA",&cut_gs_cut_dtheta);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_PIDDIFF",&cut_gs_cut_piddiff);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_OPPOSITEFLAG",&cut_gs_cut_oppositeflag);
 
        TREE_ParaSetDefinitions->GetEntry(nr);
        if (nr==-1)  {
            TREE_ParaSetDefinitions->GetEntry(0);
            if (gEDBDEBUGLEVEL>2) cout << "--- Got TREE_ParaSetDefinitions->GetEntry(0) instead of -1 due to no given PARAMETERSET_DEFINITIONFILE.root file."<<endl;
        }
        for (int i=0; i<10; i++ ) {
            CUT_PARAMETER[i]=0.0;
        }
        TREE_ParaSetDefinitions->Show(nr);
        CUT_PARAMETER[0]=cut_gs_cut_dip;
        CUT_PARAMETER[1]=cut_gs_cut_dmin;
        CUT_PARAMETER[2]=cut_gs_cut_dr;
        CUT_PARAMETER[3]=cut_gs_cut_dz;
        CUT_PARAMETER[4]=cut_gs_cut_dtheta;
        CUT_PARAMETER[5]=cut_gs_cut_piddiff;
        CUT_PARAMETER[6]=cut_gs_cut_oppositeflag;
    }
 
 
    if (gEDBDEBUGLEVEL>3) { } ;
    if (TREE_ParaSetDefinitions)TREE_ParaSetDefinitions->Show(nr);
    cout << "--- CUT_PARAMETER 0 1 2 3: " << CUT_PARAMETER[0] <<"  "<<CUT_PARAMETER[1]<<"  "<< CUT_PARAMETER[2] <<"  "<< CUT_PARAMETER[3] <<endl;
    cout << "--- CUT_PARAMETER 4 5 6 7: " << CUT_PARAMETER[4] <<"  "<<CUT_PARAMETER[5]<<"  "<< CUT_PARAMETER[6]<< "  "<< CUT_PARAMETER[7]<<"  "<<endl;
 
 
    return;
}

GetMeansBeforeAndAfter()

Int_t GetMeansBeforeAndAfter	(	Float_t &	mean_dT,
		Float_t &	mean_dR,
		EdbPVRec *	local_gAli,
		Int_t	patterloop_cnt,
		EdbSegP *	seg,
		Int_t	n_patterns,
		Int_t	BeforeOrAfter
	)

{
    //   cout << "GetMeansBeforeAndAfter( XX, " << patterloop_cnt <<  " , Seg,  " <<  n_patterns << ",  " << BeforeOrAfter << endl;
    mean_dT=-1;
    mean_dR=-1;
 
    float Z_minus1=0;
    float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
    float Z_plus1=0;
 
    int npat=local_gAli->Npatterns();
    Bool_t edge_npat_upper=kFALSE;
    Bool_t edge_npat_lower=kFALSE;
    Int_t Factor=-1;
 
    if (patterloop_cnt==npat-1) {
        edge_npat_upper=kTRUE;
    }
    if (patterloop_cnt==0) {
        edge_npat_lower=kTRUE;
    }
 
    if (!edge_npat_lower) {
        Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
        if (Z_minus1<Z_normal) Factor=1;
    }
    if (!edge_npat_upper) {
        Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
        if (Z_plus1>Z_normal) Factor=1;
    }
    // New PID we want to have:
    Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
 
    // Does this plate exist? If not, return 0 directly:
    if (patterloop_test>=npat || patterloop_test<0) {
        //cout << "So NEW n_patterns would be " << patterloop_test << " BUT IT DOES NOT MATHC in our local_gAli sceheme, which means its not existing. RETURNING 0 " << endl;
        return 0;
    }
 
    // Since we have checked now for bounds we can FindCompliments:
    Int_t n_return=0;
    TObjArray array;
    array.Clear();
    EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
    TestPattern               ->  FillCell(20,20,0.01,0.01);
    n_return = TestPattern->FindCompliments(*seg,array,3,3);
    //cout << " Found  " << n_return  << "  compliments in 2,2 sigma area:" << endl;
 
    if (n_return==0) return n_return;
 
    //seg->PrintNice();
    for (int i=0; i<n_return; i++) {
        EdbSegP* s_of_array=(EdbSegP*)array.At(i);
        if (i==0) {
            mean_dT=0;
            mean_dR=0;
        }
        //s_of_array->PrintNice();
        mean_dT+=GetdeltaThetaSingleAngles(seg,s_of_array);
        mean_dR+=GetdeltaRNoPropagation(seg,s_of_array);
    }
    if (n_return>0) mean_dT=mean_dT/(Double_t)n_return;
    if (n_return>0) mean_dR=mean_dR/(Double_t)n_return;
 
    //   cout << " mean_dT  = " <<  mean_dT  << endl;
    //   cout << " mean_dR  = " <<  mean_dR  << endl;
 
    // „Hab ich mich aus einfachsten Verhältnissen emporgequält, um dann zu bitten?“
    return n_return;
}

GetMinimumDist()

Double_t GetMinimumDist	(	EdbSegP *	s1,
		EdbSegP *	s2
	)

                                                     {
    // calculate minimum distance of 2 lines.
    // use the data of (the selected object)->X(), Y(), Z(), TX(), TY().
    // means, if the selected object == segment, use the data of the segment. or it == track, the use the fitted data.
    // original code from Tomoko Ariga
    // double calc_dmin(EdbSegP *seg1, EdbSegP *seg2, double *dminz = NULL){
 
    double x1,y1,z1,ax1,ay1;
    double x2,y2,z2,ax2,ay2;
    double s1,s2,s1bunsi,s1bunbo,s2bunsi,s2bunbo;
    double p1x,p1y,p1z,p2x,p2y,p2z,p1p2;
 
    if (seg1->ID()==seg2->ID()&&seg1->PID()==seg2->PID()) return 0.0;
 
    x1 = seg1->X();
    y1 = seg1->Y();
    z1 = seg1->Z();
    ax1= seg1->TX();
    ay1= seg1->TY();
 
    x2 = seg2->X();
    y2 = seg2->Y();
    z2 = seg2->Z();
    ax2= seg2->TX();
    ay2= seg2->TY();
 
 
    s1bunsi=(ax2*ax2+ay2*ay2+1)*(ax1*(x2-x1)+ay1*(y2-y1)+z2-z1) - (ax1*ax2+ay1*ay2+1)*(ax2*(x2-x1)+ay2*(y2-y1)+z2-z1);
    s1bunbo=(ax1*ax1+ay1*ay1+1)*(ax2*ax2+ay2*ay2+1) - (ax1*ax2+ay1*ay2+1)*(ax1*ax2+ay1*ay2+1);
    s2bunsi=(ax1*ax2+ay1*ay2+1)*(ax1*(x2-x1)+ay1*(y2-y1)+z2-z1) - (ax1*ax1+ay1*ay1+1)*(ax2*(x2-x1)+ay2*(y2-y1)+z2-z1);
    s2bunbo=(ax1*ax1+ay1*ay1+1)*(ax2*ax2+ay2*ay2+1) - (ax1*ax2+ay1*ay2+1)*(ax1*ax2+ay1*ay2+1);
    s1=s1bunsi/s1bunbo;
    s2=s2bunsi/s2bunbo;
    p1x=x1+s1*ax1;
    p1y=y1+s1*ay1;
    p1z=z1+s1*1;
    p2x=x2+s2*ax2;
    p2y=y2+s2*ay2;
    p2z=z2+s2*1;
    p1p2=sqrt( (p1x-p2x)*(p1x-p2x)+(p1y-p2y)*(p1y-p2y)+(p1z-p2z)*(p1z-p2z) );
 
 
    return p1p2;
}

GetMinsBeforeAndAfter()

Int_t GetMinsBeforeAndAfter	(	Float_t &	min_dT,
		Float_t &	min_dR,
		EdbPVRec *	local_gAli,
		Int_t	patterloop_cnt,
		EdbSegP *	seg,
		Int_t	n_patterns,
		Int_t	BeforeOrAfter
	)

{
    //   cout << "GetMinsBeforeAndAfter( XX, " << patterloop_cnt <<  " , Seg,  " <<  n_patterns << ",  " << BeforeOrAfter << endl;
    min_dT=-1;
    min_dR=-1;
 
    float Z_minus1=0;
    float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
    float Z_plus1=0;
 
    int npat=local_gAli->Npatterns();
    Bool_t edge_npat_upper=kFALSE;
    Bool_t edge_npat_lower=kFALSE;
    Int_t Factor=-1;
 
    if (patterloop_cnt==npat-1) {
        edge_npat_upper=kTRUE;
    }
    if (patterloop_cnt==0) {
        edge_npat_lower=kTRUE;
    }
 
    if (!edge_npat_lower) {
        Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
        if (Z_minus1<Z_normal) Factor=1;
    }
    if (!edge_npat_upper) {
        Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
        if (Z_plus1>Z_normal) Factor=1;
    }
    // New PID we want to have:
    Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
 
    // Does this plate exist? If not, return 0 directly:
    if (patterloop_test>=npat || patterloop_test<0) {
        //cout << "So NEW n_patterns would be " << patterloop_test << " BUT IT DOES NOT MATHC in our local_gAli sceheme, which means its not existing. RETURNING 0 " << endl;
        return 0;
    }
 
    // Since we have checked now for bounds we can FindCompliments:
    Int_t n_return=0;
    TObjArray array;
    array.Clear();
    EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
    TestPattern               ->  FillCell(20,20,0.01,0.01);
    n_return = TestPattern->FindCompliments(*seg,array,3,3);
    //cout << " Found  " << n_return  << "  compliments in 2,2 sigma area:" << endl;
 
    if (n_return==0) return n_return;
 
    if (n_return==1) {
        EdbSegP* s_of_array=(EdbSegP*)array.At(0);
        min_dT=GetdeltaThetaSingleAngles(seg,s_of_array);
        min_dR=GetdeltaRNoPropagation(seg,s_of_array);
    }
 
 
    Float_t tmp_min_dT=-1;
    Float_t tmp_min_dR=-1;
    Float_t tmp2_min_dT=-1;
    Float_t tmp2_min_dR=-1;
    Float_t angle;
    Float_t dist;
 
    if (n_return>1) {
        for (int i=0; i<n_return; i++) {
            EdbSegP* s_of_array=(EdbSegP*)array.At(i);
            if (i==0) {
                min_dT=999999;
                min_dR=9999999;
            }
            angle=(Float_t)GetdeltaThetaSingleAngles(seg,s_of_array);
            tmp_min_dT=min_dT;
            tmp2_min_dT=TMath::Min(angle, tmp_min_dT);
            min_dT=tmp2_min_dT;
 
            dist=(Float_t)GetdeltaRNoPropagation(seg,s_of_array);
            tmp_min_dR=min_dR;
            tmp2_min_dR=TMath::Min(dist, tmp_min_dR);
            min_dR=tmp2_min_dR;
        }
    }
    return n_return;
}

GetNSegBeforeAndAfter()

Int_t GetNSegBeforeAndAfter	(	EdbPVRec *	local_gAli,
		Int_t	patterloop_cnt,
		EdbSegP *	seg,
		Int_t	n_patterns,
		Int_t	BeforeOrAfter
	)

{
    //   cout << "GetNSegBeforeAndAfter( XX, " << patterloop_cnt <<  " , Seg,  " <<  n_patterns << ",  " << BeforeOrAfter << endl;
 
    float Z_minus1=0;
    float Z_normal=local_gAli->GetPattern(patterloop_cnt)->Z();
    float Z_plus1=0;
 
    int npat=local_gAli->Npatterns();
    Bool_t edge_npat_upper=kFALSE;
    Bool_t edge_npat_lower=kFALSE;
    Int_t Factor=-1;
 
    if (patterloop_cnt==npat-1) {
        edge_npat_upper=kTRUE;
    }
    if (patterloop_cnt==0) {
        edge_npat_lower=kTRUE;
    }
 
    if (!edge_npat_lower) {
        Z_minus1=local_gAli->GetPattern(patterloop_cnt-1)->Z();
        //     cout << "WHAT IS GREATER?   Z_normal  Z_minus1  " << Z_normal << "  " << Z_minus1 << endl;
        //Factor=(Int_t)TMath::Sign(Z_normal,Z_minus1);
        if (Z_minus1<Z_normal) Factor=1;
    }
    if (!edge_npat_upper) {
        Z_plus1 =local_gAli->GetPattern(patterloop_cnt+1)->Z();
        //     cout << "WHAT IS GREATER?   Z_normal  Z_plus1  " << Z_normal << "  " << Z_plus1 << endl;
        if (Z_plus1>Z_normal) Factor=1;
    }
 
    //   cout << Z_minus1 << endl;
    //   cout << Z_normal << endl;
    //   cout << Z_plus1 << endl;
    //   cout << "Is edge_npat_lower = " << edge_npat_lower << endl;
    //   cout << "Is edge_npat_upper = " << edge_npat_upper << endl;
    //   cout << "Factor =  " << Factor << endl;
 
    // New PID we want to have:
    Int_t patterloop_test=patterloop_cnt+Factor*n_patterns*BeforeOrAfter;
    //   cout << "So NEW n_patterns would be " << patterloop_test << endl;
 
    // Does this plate exist? If not, return 0 directly:
    if (patterloop_test>=npat || patterloop_test<0) {
        //cout << "So NEW n_patterns would be " << patterloop_test << " BUT IT DOES NOT MATHC in our local_gAli sceheme, which means its not existing. RETURNING 0 " << endl;
        return 0;
    }
 
    // Since we have checked now for bounds we can FindCompliments:
    TObjArray array;
    array.Clear();
    EdbPattern* TestPattern= (EdbPattern*)local_gAli->GetPattern(patterloop_test);
    TestPattern               ->  FillCell(20,20,0.01,0.01);
    int n_return = TestPattern->FindCompliments(*seg,array,3,3);
    //cout << " Found  " << n_return  << "  compliments in 2,2 sigma area:" << endl;
 
    return n_return;
}

GetSpatialDist()

Double_t GetSpatialDist	(	EdbSegP *	s1,
		EdbSegP *	s2
	)

{
    Log(4, "ShowRec.cpp", "--- Bool_t GetSpatialDist() ---");
    // Mainly Z values should dominate... since the are at the order of 10k microns and x,y of 1k microns
    Double_t x1,x2,y1,y2,z1,z2;
    x1=s1->X();
    x2=s2->X();
    y1=s1->Y();
    y2=s2->Y();
    z1=s1->Z();
    z2=s2->Z();
    Double_t dist= TMath::Sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2)  );
    //cout << "dist = "  <<  dist << endl;
    return dist;
}

IsSameSegment()

Bool_t IsSameSegment	(	EdbSegP *	seg1,
		EdbSegP *	seg2
	)

                                                  {
    if (TMath::Abs(seg1->X()-seg2->X())<0.01) {
        if (TMath::Abs(seg1->Y()-seg2->Y())<0.01) {
            if (TMath::Abs(seg1->TY()-seg2->TY())<0.01) {
                if (TMath::Abs(seg1->TX()-seg2->TX())<0.01) {
                    return kTRUE;
                }
            }
        }
    }
    return kFALSE;
}

IsShowerSortedZ()

Bool_t IsShowerSortedZ

(

TObjArray *

showerarray

)

                                               {
    // Condition: z[0]<= z[1]<=....<=z[nseg]
    if (showerarray->GetEntries()<1) return kTRUE;
    EdbSegP* s0;
    EdbSegP* s1;
    for (int i=0; i<showerarray->GetEntries()-1; i++) {
        s0= (EdbSegP*)showerarray->At(i);
        s1= (EdbSegP*)showerarray->At(i+1);
        if (s0->Z()>s1->Z()) return kFALSE;
    }
    return kTRUE;
}

Load_NN_ALG_MLP_weights()

void Load_NN_ALG_MLP_weights	(	TMultiLayerPerceptron *	mlp,
		Int_t	parasetnr
	)

{
    int ann_inputneurons=CUT_PARAMETER[1];
 
    if (ann_inputneurons==5) {
        mlp->LoadWeights("ANN_WEIGHTS_PARASET_0_To_20.txt");
        gSystem->Exec("ls -ltr ANN_WEIGHTS_PARASET_0_To_20.txt");
    }
    if (ann_inputneurons==10) {
        mlp->LoadWeights("ANN_WEIGHTS_PARASET_20_To_40.txt");
    }
    if (ann_inputneurons==20) {
        mlp->LoadWeights("ANN_WEIGHTS_PARASET_40_To_60.txt");
    }
    if (ann_inputneurons==30) {
        mlp->LoadWeights("ANN_WEIGHTS_PARASET_60_To_80.txt");
    }
 
    mlp->GetStructure();
 
    return;
}

MakeTracksTree()

void MakeTracksTree

(

TTree *

treebranch

)

{
    if (cmd_OUTPUTLEVEL<2) return;
 
    Log(2, "ShowRec.cpp", "--- void MakeTracksTree() ---");
    if (gEDBDEBUGLEVEL>3) cout <<"--- --- MakeTracksTree Part 2:"<<endl;
 
    //   cout << treebranch->GetName() <<  "           treebranch->GetName(); " << endl;
 
    EdbSegP *seg;
    EdbTrackP *track2;
    EdbPVRec *ali;
    ali = new EdbPVRec();
    EdbPattern *pat=0;
    char fname_e[128];
    float x,y,tx,ty,z;
    int w2;
 
    for (int i=0; i<treebranch->GetEntries(); ++i) {
        treebranch->GetEntry(i);
        track2 = new EdbTrackP();
 
        for (int j=0; j<shower_sizeb; ++j)  {
 
            x=shower_xb[j];
            y=shower_yb[j];
            tx=shower_txb[j];
            ty=shower_tyb[j];
            z=shower_zb[j];
            w2=shower_ntrace2simub[j];
 
            seg = new EdbSegP();
            seg->Set(j, x, y, tx, ty, w2, 0);
            seg->SetZ(z);
            seg->SetDZ(300.);
            // DISPLAY PROBLEM IF RIGHT PID IS USED !!!!!!!!!!!!!!
            pat = ali->GetPattern( seg->PID() );
            if (!pat) {
                printf("WARNING: no pattern with pid %d: creating new one!\n",seg->PID());
                pat = new EdbPattern( 0., 0., seg->Z() );
                //pat->SetID(seg->PID());
                ali->AddPatternAt(pat,seg->PID());
                ali->AddPatternAt(pat,j);
            }
            pat->AddSegment(*seg);
            track2->AddSegment(seg);
        }
        track2->SetSegmentsTrack(i);
        track2->SetID(i);
        track2->SetNpl(shower_nfilmb[shower_sizeb-1]);
        track2->SetProb(1.);
        track2->SetFlag(10);
        track2->FitTrack();
        ali->AddTrack(track2);
 
        //     cout << "i = delete track2"<< i << endl;
        //     delete track2;track2=0;
    }
    if (gEDBDEBUGLEVEL>3) ali->Print();
 
    //   if (gEDBDEBUGLEVEL>3)
    //     cout <<"--- --- MakeTracksTree Part 2:"<<endl;
 
    if (!ali) return;
    TObjArray *trarr = ali->eTracks;
    if (!trarr) return;
    float xv;
    xv=ali->X();
    float yv;
    yv=ali->Y();
 
    //   if (gEDBDEBUGLEVEL>2)
    //     cout <<"--- Write tracks to file:  " << FILE_ShowTracks->GetName() <<endl;
 
    TString tracksname="tracks"+TString(treebranch->GetName());
 
    FILE_ShowTracks->cd();
    //   TFile::Open(FILE_ShowTracks->GetName(),"UPDATE");
    TTree *tracks= new TTree(tracksname,tracksname);
    tracks->SetDirectory(FILE_ShowTracks);
    if (gEDBDEBUGLEVEL>2) cout <<"--- tracks->SetDirectory(FILE_ShowTracks)"<<endl;
 
 
    EdbTrackP    *track = new EdbTrackP(8);
    EdbSegP      *tr = (EdbSegP*)track;
    TClonesArray *segments  = new TClonesArray("EdbSegP");
    TClonesArray *segmentsf  = new TClonesArray("EdbSegP");
 
    int   nseg,trid,npl,n0;
    float w=0.;
 
    tracks->Branch("trid",&trid,"trid/I");
    tracks->Branch("nseg",&nseg,"nseg/I");
    tracks->Branch("npl",&npl,"npl/I");
    tracks->Branch("n0",&n0,"n0/I");
    tracks->Branch("xv",&xv,"xv/F");
    tracks->Branch("yv",&yv,"yv/F");
    tracks->Branch("w",&w,"w/F");
    tracks->Branch("t.","EdbSegP",&tr,32000,99);
    tracks->Branch("s", &segments);
    //fitted segments is kept for linked_track.root compability
    tracks->Branch("sf",&segmentsf);
 
    int ntr = trarr->GetEntriesFast();
 
    if (gEDBDEBUGLEVEL>2) cout <<"--- ntr = trarr->GetEntriesFast(); " << ntr << "    "  << trarr->GetEntries() << endl;
 
    for (int itr=0; itr<ntr; itr++) {
        track = (EdbTrackP*)(trarr->At(itr));
        trid = track->ID();
        nseg = track->N();
        npl  = track->Npl();
        n0   = track->N0();
        tr = (EdbSegP*)track;
        segments->Clear("C");
        nseg = track->N();
        w    = track->Wgrains();
        EdbSegP *s=0,*sf=0;
        for (int is=0; is<nseg; is++) {
            s = track->GetSegment(is);
            if (s) new((*segments)[is])  EdbSegP( *s );
            sf = track->GetSegment(is);
            if (sf) new((*segmentsf)[is])  EdbSegP( *sf );
        }
        track->SetVid( 0, tracks->GetEntries() );  // put track counter in t.eVid[1]
        tracks->Fill();
        track->Clear();
    }
    tracks->Write();
 
 
 
    return;
}

Open_ParasetDefinitionFile()

Int_t Open_ParasetDefinitionFile

(

)

{
    Log(2, "ShowRec.cpp", "--- Int_t Open_ParasetDefinitionFile() ---");
 
    FILE_ParaSetDefinitions = new TFile("PARAMETERSET_DEFINITIONFILE.root","READ");
    TREE_ParaSetDefinitions = 0;
    TREE_ParaSetDefinitions = (TTree*)FILE_ParaSetDefinitions->Get("ParaSet_Variables");
 
    if (gEDBDEBUGLEVEL>2) if (TREE_ParaSetDefinitions!=0) TREE_ParaSetDefinitions->Print();
    if (gEDBDEBUGLEVEL>2) if (TREE_ParaSetDefinitions==0) cout << "WARNING: In --- Open_ParasetDefinitionFile ---  Empty TREE_ParaSetDefinitions."<<endl;
 
    return 1;
}

PrintShowerObjectArray()

void PrintShowerObjectArray

(

TObjArray *

segarray

)

{
    Log(3, "ShowRec.cpp", "--- Bool_t PrintShowerObjectArray() ---");
 
    if (gEDBDEBUGLEVEL>2) cout << "--- -----------------------------------------"<<endl;
    Int_t nent=segarray->GetEntries();
    if (gEDBDEBUGLEVEL>2) cout << "--- segarray->GetEntries:   " << nent << endl;
    EdbSegP* s;
    if (gEDBDEBUGLEVEL>2) printf("Entry X  Y  Z  TX  TY  W  Chi2  MCEvt  PID  P  Flag\n");
    for (int i=0; i<nent; i++)  {
        s=(EdbSegP*)segarray->At(i);
        if (gEDBDEBUGLEVEL>2) printf("%8d %14.3f  %14.3f  %14.3f  %7.4f  %7.4f  %7.4f  %7.4f  %8d %8d %6.2f %6d\n", i, s->X(), s->Y(), s->Z(), s->TX(), s->TY(),s->W(),s->Chi2(),s->MCEvt(), s->PID(), s->P(), s->Flag());
    }
    if (gEDBDEBUGLEVEL>2) cout << "--- -----------------------------------------"<<endl;
    Log(3, "ShowRec.cpp", "--- Bool_t PrintShowerObjectArray() done.");
    return;
}

Read_ParasetDefinitionTree()

void Read_ParasetDefinitionTree

(

)

{
    Log(2, "ShowRec.cpp", "--- Int_t Read_ParasetDefinitionTree() ---");
 
    Double_t dr_max,dt_max,coneangle,tubedist;
    Int_t    nholes_max;
    Double_t ann_output;
    Int_t ann_inputneurons;
    Double_t  CUT_P;
    Double_t  CUT_ALISUBSIZE;
    Double_t distMin_max;
    Int_t  tracksegs_max;
    Double_t distMin_dt_max;
    Double_t cut_back_dmin,cut_for_dmin,cut_back_dtheta,cut_for_dtheta,cut_back_dr,cut_for_dr,cut_back_dz,cut_for_dz;
 
    // ALTP 10:  GS from libShowRec
    Double_t cut_gs_cut_dip=150;
    Double_t cut_gs_cut_dmin=40;
    Double_t cut_gs_cut_dr=60;
    Double_t cut_gs_cut_dz=19000;
    Double_t cut_gs_cut_dtheta=0.06;
    Double_t cut_gs_cut_piddiff=1;
    Int_t cut_gs_cut_oppositeflag=0;
 
    // Create on Tree if its not there and fill it with one entry:
    if (TREE_ParaSetDefinitions==0 && (cmd_ALTP==0 || cmd_ALTP==2 || cmd_ALTP==4)) {
        if (TREE_ParaSetDefinitions==0) cout << "WARNING: In --- Read_ParasetDefinitionTree ---  Empty TREE_ParaSetDefinitions. Using only one, standard parameterset  (...) ."<<endl;
        TREE_ParaSetDefinitions = new TTree("ParaSet_Variables","ParaSet_Variables");
        TREE_ParaSetDefinitions -> Branch("CUT_ZYLINDER_R_MAX",&tubedist,"CUT_ZYLINDER_R_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_ZYLINDER_ANGLE_MAX",&coneangle,"CUT_ZYLINDER_ANGLE_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max,"CUT_SHOWERFOLLOWERBT_DR_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max,"CUT_SHOWERFOLLOWERBT_DTAN_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_NHOLES_MAX",&nholes_max,"CUT_NHOLES_MAX/I");
        dr_max=100.0;
        dt_max=0.1;
        coneangle=0.1;
        tubedist=800.0;
        nholes_max=3;
 
        if (cmd_ALTP==0||cmd_ALTP==2) {
            if (cmd_CUTTP==2) {
                cout << "----- cmd_CUTTP==2 -----"<<endl;
                dr_max=100.0;
                dt_max=0.1;
                coneangle=0.1;
                tubedist=800.0;
            }
            else if (cmd_CUTTP==1) {
                cout << "----- cmd_CUTTP==1 -----"<<endl;
                dr_max=100.0;
                dt_max=0.1;
                coneangle=0.1;
                tubedist=800.0;
            }
            else {
                cout << "----- cmd_CUTTP==else -----"<<endl;
                dr_max=100.0;
                dt_max=0.1;
                coneangle=0.1;
                tubedist=800.0; // CA ALG, cmd_ALTP==2 , CT ALG, cmd_ALTP==0
            }
        }
        if (cmd_ALTP==4) {
            if (cmd_CUTTP==4) {
                cout << "----- cmd_CUTTP==4 : FJ_Standard -----"<<endl;
                dr_max=150.0;
                dt_max=0.15;
                coneangle=0.02;
                tubedist=800.0; // cuttype. FJ_Standard   // OI ALG, cmd_ALTP==4
            }
            if (cmd_CUTTP==3) {
                cout << "----- cmd_CUTTP==3 : FJ_HighPur -----"<<endl;
                dr_max=100.0;
                dt_max=0.05;
                coneangle=0.025;
                tubedist=400.0; // cuttype. FJ_HighPur   // OI ALG, cmd_ALTP==4
            }
            else if (cmd_CUTTP==2) {
                cout << "----- cmd_CUTTP==2 -----"<<endl;
                dr_max=200.0;
                dt_max=0.15;
                coneangle=0.03;
                tubedist=800.0; // cuttype. high eff   // OI ALG, cmd_ALTP==4
            }
            else if (cmd_CUTTP==1) {
                cout << "----- cmd_CUTTP==1 -----"<<endl;
                dr_max=120.0;
                dt_max=0.11;
                coneangle=0.02;
                tubedist=600.0; // cuttype. high pur   // OI ALG, cmd_ALTP==4
            }
            else {
                cout << "----- cmd_CUTTP==else -----"<<endl;
                dr_max=150.0;
                dt_max=0.15;
                coneangle=0.02;
                tubedist=800.0; // cuttype. FJ_Standard   // OI ALG, cmd_ALTP==4
            }
        }
 
        //cout << "----------- SAME VALUES AS IN EdbShowerRec FOR tESTING... REMOVE AFTER YOURE DONE HERE!!"<<endl;
        //if (cmd_ALTP==4) dr_max=150.0;dt_max=0.15;coneangle=0.02;tubedist=800.0; // OI ALG, cmd_ALTP==4
 
        // ParaSetNr  CUT_ZYLINDER_R_MAX CUT_ZYLINDER_ANGLE_MAX CUT_SHOWERFOLLOWERBT_DR_MAX CUT_SHOWERFOLLOWERBT_DTAN_MAX
        // 7001    800  0.1  100  0.1 (high NBT, middle purity)
        // 4401    500  0.5  100  0.1 (middle NBT, high purity) (comparable to off. Recoalg.);
 
        TREE_ParaSetDefinitions -> Fill();
        if (gEDBDEBUGLEVEL>2) cout << "--- TREE_ParaSetDefinitions -> GetEntries()  " << TREE_ParaSetDefinitions -> GetEntries()<<endl;
        if (gEDBDEBUGLEVEL>3) TREE_ParaSetDefinitions -> Show(TREE_ParaSetDefinitions -> GetEntries()-1);
 
        // Reset here then also command line arguments:
        //              cmd_PASTART=0; cmd_PAEND=0;
        // Update CUT_PARAMETER[0,1,2,3,]
    }
 
    if (TREE_ParaSetDefinitions==0 && cmd_ALTP==3) {
        TREE_ParaSetDefinitions = new TTree("ParaSet_Variables","ParaSet_Variables");
        TREE_ParaSetDefinitions -> Branch("CUT_ANN_INPUTNEURONS",&ann_inputneurons,"CUT_ANN_INPUTNEURONS/I");
        TREE_ParaSetDefinitions -> Branch("CUT_ANN_OUTPUT",&ann_output,"CUT_ANN_OUTPUT/D");
        ann_output=0.85;
        ann_inputneurons=5;
        TREE_ParaSetDefinitions -> Fill();
        TREE_ParaSetDefinitions -> Show(TREE_ParaSetDefinitions -> GetEntries()-1);
        TREE_ParaSetDefinitions->Print();
    }
 
 
    if (TREE_ParaSetDefinitions==0 && cmd_ALTP==5) {
        TREE_ParaSetDefinitions = new TTree("ParaSet_Variables","ParaSet_Variables");
        TREE_ParaSetDefinitions -> Branch("CUT_P",&CUT_P,"CUT_P/D");
        TREE_ParaSetDefinitions -> Branch("CUT_ALISUBSIZE",&CUT_ALISUBSIZE,"CUT_ALISUBSIZE/D");
        CUT_P=0;
        CUT_ALISUBSIZE=1000;
        TREE_ParaSetDefinitions -> Fill();
        TREE_ParaSetDefinitions -> Show(TREE_ParaSetDefinitions -> GetEntries()-1);
        TREE_ParaSetDefinitions->Print();
    }
 
    if (TREE_ParaSetDefinitions==0 && cmd_ALTP==6) {
        TREE_ParaSetDefinitions = new TTree("ParaSet_Variables","ParaSet_Variables");
        TREE_ParaSetDefinitions -> Branch("CUT_ZYLINDER_R_MAX",&tubedist,"CUT_ZYLINDER_R_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_ZYLINDER_ANGLE_MAX",&coneangle,"CUT_ZYLINDER_ANGLE_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max,"CUT_SHOWERFOLLOWERBT_DR_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max,"CUT_SHOWERFOLLOWERBT_DTAN_MAX/D");
 
        TREE_ParaSetDefinitions -> Branch("CUT_TRACKATTACH_DISTMIN",&distMin_max,"CUT_TRACKATTACH_DISTMIN/D");
        TREE_ParaSetDefinitions -> Branch("CUT_TRACKATTACH_DTAN_MAX",&distMin_dt_max,"CUT_TRACKATTACH_DTAN_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_TRACKATTACH_NTRACKSEG",&tracksegs_max,"CUT_TRACKATTACH_NTRACKSEG/I");
 
        dr_max=150.0;
        dt_max=0.13;
        coneangle=0.025;
        tubedist=700.0;
        distMin_max=500;
        tracksegs_max=1;
        distMin_dt_max=200;
        TREE_ParaSetDefinitions -> Fill();
        TREE_ParaSetDefinitions -> Show(TREE_ParaSetDefinitions -> GetEntries()-1);
        TREE_ParaSetDefinitions->Print();
    }
 
 
    if (TREE_ParaSetDefinitions==0 && (cmd_ALTP==7 || cmd_ALTP==9)) {
        TREE_ParaSetDefinitions = new TTree("ParaSet_Variables","ParaSet_Variables");
        TREE_ParaSetDefinitions -> Branch("CUT_ZYLINDER_R_MAX",&tubedist,"CUT_ZYLINDER_R_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_ZYLINDER_ANGLE_MAX",&coneangle,"CUT_ZYLINDER_ANGLE_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max,"CUT_SHOWERFOLLOWERBT_DR_MAX/D");
        TREE_ParaSetDefinitions -> Branch("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max,"CUT_SHOWERFOLLOWERBT_DTAN_MAX/D");
        dr_max=150.0;
        dt_max=0.13;
        coneangle=0.025;
        tubedist=700.0;
        TREE_ParaSetDefinitions -> Fill();
        TREE_ParaSetDefinitions -> Show(TREE_ParaSetDefinitions -> GetEntries()-1);
        TREE_ParaSetDefinitions->Print();
    }
 
 
    if (TREE_ParaSetDefinitions==0 && cmd_ALTP==8) {
        TREE_ParaSetDefinitions = new TTree("ParaSet_Variables","ParaSet_Variables");
        TREE_ParaSetDefinitions -> Branch("CUT_BACK_DMIN",&cut_back_dmin,"CUT_BACK_DMIN/D");
        TREE_ParaSetDefinitions -> Branch("CUT_BACK_DTHETA",&cut_back_dtheta,"CUT_BACK_DTHETA/D");
        TREE_ParaSetDefinitions -> Branch("CUT_BACK_DR",&cut_back_dr,"CUT_BACK_DR/D");
        TREE_ParaSetDefinitions -> Branch("CUT_BACK_DZ",&cut_back_dz,"CUT_BACK_DZ/D");
        TREE_ParaSetDefinitions -> Branch("CUT_FOR_DMIN",&cut_for_dmin,"CUT_FOR_DMIN/D");
        TREE_ParaSetDefinitions -> Branch("CUT_FOR_DTHETA",&cut_for_dtheta,"CUT_FOR_DTHETA/D");
        TREE_ParaSetDefinitions -> Branch("CUT_FOR_DR",&cut_for_dr,"CUT_FOR_DR/D");
        TREE_ParaSetDefinitions -> Branch("CUT_FOR_DZ",&cut_for_dz,"CUT_FOR_DZ/D");
        cut_back_dmin=cut_for_dmin=120;
        cut_back_dtheta=cut_for_dtheta=0.120;
        cut_back_dr=cut_for_dr=120;
        cut_back_dz=cut_for_dz=5000;
        TREE_ParaSetDefinitions -> Fill();
        TREE_ParaSetDefinitions -> Show(TREE_ParaSetDefinitions -> GetEntries()-1);
        TREE_ParaSetDefinitions->Print();
    }
 
 
 
    if (TREE_ParaSetDefinitions==0 && cmd_ALTP==10) {
        TREE_ParaSetDefinitions = new TTree("ParaSet_Variables","ParaSet_Variables");
        TREE_ParaSetDefinitions -> Branch("CUT_GS_CUT_DIP",&cut_gs_cut_dip,"CUT_GS_CUT_DIP/D");
        TREE_ParaSetDefinitions -> Branch("CUT_GS_CUT_DMIN",&cut_gs_cut_dmin,"CUT_GS_CUT_DMIN/D");
        TREE_ParaSetDefinitions -> Branch("CUT_GS_CUT_DR",&cut_gs_cut_dr,"CUT_GS_CUT_DR/D");
        TREE_ParaSetDefinitions -> Branch("CUT_GS_CUT_DZ",&cut_gs_cut_dz,"CUT_GS_CUT_DZ/D");
        TREE_ParaSetDefinitions -> Branch("CUT_GS_CUT_DTHETA",&cut_gs_cut_dtheta,"CUT_GS_CUT_DTHETA/D");
        TREE_ParaSetDefinitions -> Branch("CUT_GS_CUT_PIDDIFF",&cut_gs_cut_piddiff,"CUT_GS_CUT_PIDDIFF/D");
        TREE_ParaSetDefinitions -> Branch("CUT_GS_CUT_OPPOSITEFLAG",&cut_gs_cut_oppositeflag,"CUT_GS_CUT_OPPOSITEFLAG/I");
        // PARAMETERSET_DEFINITIONFILE_LONG_GS_ALG.txt:  19642    393.212  35.5454  85.268  25062.6  0.117141  3  0
        cut_gs_cut_dip=393;
        cut_gs_cut_dmin=35.5;
        cut_gs_cut_dr=85.;
        cut_gs_cut_dz=25000;
        cut_gs_cut_dtheta=0.11;
        cut_gs_cut_piddiff=1;
        cut_gs_cut_oppositeflag=0;
        TREE_ParaSetDefinitions -> Fill();
        TREE_ParaSetDefinitions -> Show(TREE_ParaSetDefinitions -> GetEntries()-1);
        TREE_ParaSetDefinitions->Print();
    }
 
 
 
    if              (cmd_ALTP==0) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
    }
    else if     (cmd_ALTP==1) {
        cout << "TODO"<<endl;
    }
    else if     (cmd_ALTP==2) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
    }
    else if     (cmd_ALTP==4) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_NHOLES_MAX",&nholes_max);
    }
    else if     (cmd_ALTP==5) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_P",&CUT_P);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ALISUBSIZE",&CUT_ALISUBSIZE);
    }
    else if     (cmd_ALTP==3) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ANN_OUTPUT",&ann_output);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_ANN_INPUTNEURONS",&ann_inputneurons);
    }
 
    else if   (cmd_ALTP==6) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_TRACKATTACH_DISTMIN",&distMin_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_TRACKATTACH_DTAN_MAX",&distMin_dt_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_TRACKATTACH_NTRACKSEG",&tracksegs_max);
    }
    else if   (cmd_ALTP==7) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_R_MAX",&tubedist);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_ZYLINDER_ANGLE_MAX",&coneangle);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DR_MAX",&dr_max);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_SHOWERFOLLOWERBT_DTAN_MAX",&dt_max);
    }
    else if   (cmd_ALTP==8) {
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_BACK_DMIN",&cut_back_dmin);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_BACK_DTHETA",&cut_back_dtheta);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_BACK_DR",&cut_back_dr);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_BACK_DZ",&cut_back_dz);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_FOR_DMIN",&cut_for_dmin);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_FOR_DTHETA",&cut_for_dtheta);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_FOR_DR",&cut_for_dr);
        TREE_ParaSetDefinitions->SetBranchAddress("CUT_FOR_DZ",&cut_for_dz);
    }
 
    else if (cmd_ALTP==10) {
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DIP",&cut_gs_cut_dip);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DMIN",&cut_gs_cut_dmin);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DR",&cut_gs_cut_dr);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DZ",&cut_gs_cut_dz);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_DTHETA",&cut_gs_cut_dtheta);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_PIDDIFF",&cut_gs_cut_piddiff);
        TREE_ParaSetDefinitions -> SetBranchAddress("CUT_GS_CUT_OPPOSITEFLAG",&cut_gs_cut_oppositeflag);
    }
 
    // Check: if PASTART is given (a number),  but PAEND is default, then set
    // PAEND to PASTART
    if (cmd_PASTART>=0 && cmd_PAEND==-1) cmd_PAEND=cmd_PASTART;
 
    if (gEDBDEBUGLEVEL>2) cout << "--- Updated commandline values: cmd_PASTART=" << cmd_PASTART << " and  cmd_PAEND=" << cmd_PAEND << endl;
 
    return;
}

ReadDefaultValues_CommandLine()

void ReadDefaultValues_CommandLine

(

)

                                     {
 
    cout << "-----------------------------------------------"<<endl;
    cout << "---      \t\t :     -FP        FirstPlate " << cmd_FP << endl;
    cout << "---      \t\t :     -LP        LastPlate  " << cmd_LP << endl;
    cout << "---      \t\t :     -MP        MiddlePlate " << cmd_MP << endl;
    cout << "---      \t\t :     -NP        NumberofPlates  " << cmd_NP << endl;
    cout << "---      \t\t :     -LT        use LinkedTracks.root " << cmd_LT << endl;
    cout << "---      \t\t :     -MC        use only MC Events  " << cmd_MC << endl;
    cout << "---      \t\t :     -MCFL      use only MC Flag  " << cmd_MCFL << endl;
    cout << "---      \t\t :     -FZHP      use first Z-position of Event Occurence " << cmd_FZHP << endl;
    cout << "---      \t\t :     -ALI       use which Ali  " << cmd_ALI << endl;
    cout << "---      \t\t :     -MCMIX     use MCMIX :DANGEROUS !!! ... Be Careful! " << cmd_MCMIX << endl;
    cout << "---      \t\t :     -EXTHETA       Extract Subpattern with Delta Theta Cut on Initiator BT angle " << cmd_EXTHETA << endl;
    cout << "---      \t\t :     -VTX       For InBT: Cut to IP for MC vertex    " << cmd_vtx << endl;
    cout << "---      \t\t :     -PADI      ParentDirectory  " << cmd_PADI << endl;
    cout << "---      \t\t :     -BTPA      BasetrackParametrisation  " << cmd_BTPA << endl;
    cout << "---      \t\t :     -BGTP      BackgroundType " << cmd_BGTP << endl;
    cout << "---      \t\t :     -ALTP      AlgorythmType " << cmd_ALTP << endl;
    cout << "---      \t\t :     -PASTART   ParametersetStart " << cmd_PASTART << endl;
    cout << "---      \t\t :     -PAEND     ParameterSetEnd " << cmd_PAEND << endl;
    cout << "---      \t\t :     -CUTTP     Algo Cuttype " << cmd_CUTTP << endl;
    cout << "---      \t\t :     -CLEAN     InputData BG Cleaning " << cmd_CLEAN << endl;
    cout << "---      \t\t :     -FILETP    FILE Type tag " << cmd_FILETP << endl;
    cout << "---      \t\t :     -GBMC      Global MC Evt type tag " << cmd_GBMC << endl;
    cout << "---      \t\t :     -DEBUG     DEBUGLEVEL " << cmd_gEDBDEBUGLEVEL << endl;
    cout << "---      \t\t :     -OUT       OUTPUTLEVEL " << cmd_OUTPUTLEVEL << endl;
    cout << "---      \t\t :     -STOP      STOPLEVEL " << cmd_STOPLEVEL << endl;
    cout << "-----------------------------------------------"<<endl<<endl;
    return;
}

ReadEdbPVRecObjectFromCurrentDirectory()

EdbPVRec* ReadEdbPVRecObjectFromCurrentDirectory

(

)

{
    Log(2, "ShowRec.cpp", "--- EdbPVRec* ReadEdbPVRecObjectFromCurrentDirectory() ---");
 
    // Create EdbPVRec on the heap:
    EdbPVRec *gAli= new EdbPVRec();
 
//   cmd_ALI==0: read gAli from lnk.def Basetracks
//   cmd_ALI==1: read gAli from linked.tracks.root
//   cmd_ALI==2: read gAli from ScanVolume_Ali.root
//   cmd_ALI==3: read gAli from ScanVolumeLinkedTracks_Ali.root
 
    if (cmd_ALI==3) {
        Log(2, "ShowRec.cpp", "--- EdbPVRec* ReadEdbPVRecObjectFromCurrentDirectory() cmd_ALI==3: read gAli from ScanVolumeLinkedTracks_Ali.root");
        TFile* f= new TFile("ScanVolumeLinkedTracks_Ali.root");
        gAli= (EdbPVRec*) f->Get("EdbPVRec");
        return gAli;
    }
    if (cmd_ALI==2) {
        Log(2, "ShowRec.cpp", "--- EdbPVRec* ReadEdbPVRecObjectFromCurrentDirectory() cmd_ALI==2: read gAli from ScanVolume_Ali.root");
        TFile* f= new TFile("ScanVolume_Ali.root");
        f->ls();
        gAli= (EdbPVRec*) f->Get("EdbPVRec");
        return gAli;
    }
 
    //-----------------------------------
    // current dir has to contain:
    // default.par, lnk_all.lst, lnk_all.def
    // data, par directory
    //-----------------------------------
    // DECLARE MAIN OBJECTS
    EdbDataProc     *dset;
    // Data set initialization
    dset = new EdbDataProc("lnk_all.def");
    // Volume initialization
    // The differentiation LT or not is made when Filling the array
    // new: (4.2.2010) can distinguish between gAli from cp.root or from linked tracks
 
    if (cmd_ALI==1) {
        Log(2, "ShowRec.cpp", "--- EdbPVRec* ReadEdbPVRecObjectFromCurrentDirectory() cmd_ALI==1: read gAli from linked.tracks.root");
        dset->InitVolume(100, "");  // Read in (all) BT from linked_tracks.root
    }
    if (cmd_ALI==0) {
        Log(2, "ShowRec.cpp", "--- EdbPVRec* ReadEdbPVRecObjectFromCurrentDirectory() cmd_ALI==0: read gAli from lnk.def Basetracks");
 
        dset->InitVolume(0, "");    // Read in (all) BT from cp.root.
    }
 
    // Create EdbPVRec on the heap:
//   EdbPVRec *gAli= new EdbPVRec();
    // Get Pattern Volume Reconstruction object
    gAli = dset->PVR();
    //-------------------------------------
    if (gEDBDEBUGLEVEL>3)  gAli->Print();
    //-------------------------------------
    return gAli;
}

Reco_CL_AssignZValueToGroup()

Int_t Reco_CL_AssignZValueToGroup	(	Double_t	z,
		Double_t	z0,
		Int_t	NGroupedPLATES,
		Int_t	PLATESPerGroup
	)

{
    // z:  Position of BT to be checked,
    // z0: ZStart if for example FIRSTPLATE z=3900 (PLATE 4) instead of 0
    Int_t actplate=(Int_t)(z-z0)/1300+1;
    Int_t actgroup=(actplate-1)/PLATESPerGroup;
    //  cout << "z  z0 actplate "<< z << "   " << z0 << "  " <<actplate << endl;
    //  cout << "actplate  actgroup "<< actplate << "   " << actgroup << endl;
    //This Assignment seems ok.
    return actgroup;
}

Reco_CL_BuildGlobalHistogramsOnHeap()

void Reco_CL_BuildGlobalHistogramsOnHeap

(

)

{
    TString HistoNameTitle="XXX";
    for (Int_t h=0; h<50; h++) {
        //          cout << "Creating    Hist2DimOnlyBG_Groupe_ " << h << endl;
        HistoNameTitle=TString(Form("Hist2DimOnlyBG_Groupe_%d",h));
        Hist2DimOnlyBGOneGroupedPlate[h]=new TH2F(HistoNameTitle,HistoNameTitle,10,0,1,10,0,1);
        //          cout << "Creating    Hist2DimOnlySimOneEvent_Groupe_ " << h << endl;
        HistoNameTitle=TString(Form("Hist2DimOnlySimOneEvent_Groupe_%d",h));
        Hist2DimOnlySimOneEventOneGroupedPlate[h]=new  TH2F(HistoNameTitle,HistoNameTitle,10,0,1,10,0,1);
        //          cout << "Creating    Hist2DimBGAndSimOneEvent_Groupe_ " << h << endl;
        HistoNameTitle=TString(Form("Hist2DimBGAndSimOneEvent_Groupe_%d",h));
        Hist2DimBGAndSimOneEventOneGroupedPlate[h]=new  TH2F(HistoNameTitle,HistoNameTitle,10,0,1,10,0,1);
    }
    return;
}

ReconstructShowers()

void ReconstructShowers

(

Int_t

nr

)

MakeTracksTree(TREE_ShowShower);

MakeTracksTree(TREE_ShowShower);

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers() ---");
 
 
    //-----------------------------------
    // Create the ShowerOutputtree:
    TREE_ShowShower = CreateTreeBranchShowerTree(GLOBAL_PARASETNR);
    //-----------------------------------
 
 
    //-----------------------------------
    // Call main Reconstruction function:
    //-----------------------------------
    if              (cmd_ALTP==0) {
        cout << "ReconstructShowers::   cmd_ALTP==0   ReconstructShowers_CT()      IS NOW THE SAME AS CA ALG!  "<< endl;
        cout << "ReconstructShowers::   cmd_ALTP==0   ReconstructShowers_CTA()   Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_CT();
    }
    else if     (cmd_ALTP==1) {
        cout << "TODO... CL ...."<<endl;
        ReconstructShowers_CL();
    }
    else if     (cmd_ALTP==2) {
        cout << "ReconstructShowers::   cmd_ALTP==2   ReconstructShowers_CA()   Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_CA();
    }
    else if     (cmd_ALTP==3) {
        cout << "ReconstructShowers::   cmd_ALTP==3   ReconstructShowers_NN()    Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_NN();
    }
    else if     (cmd_ALTP==4) {
        cout << "ReconstructShowers::   cmd_ALTP==4   ReconstructShowers_OI()    Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_OI();
    }
    else if     (cmd_ALTP==5) {
        cout << "ReconstructShowers::   cmd_ALTP==5   ReconstructShowers_SA()   Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_SA();
    }
    else if   (cmd_ALTP==6) {
        cout << "ReconstructShowers::   cmd_ALTP==6   ReconstructShowers_TC()   Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_TC();
    }
    else if   (cmd_ALTP==7) {
        cout << "ReconstructShowers::   cmd_ALTP==7   ReconstructShowers_RC()   Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_RC();
    }
    else if   (cmd_ALTP==8) {
        cout << "ReconstructShowers::   cmd_ALTP==8   ReconstructShowers_BW()   Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_BW();
    }
    else if   (cmd_ALTP==9) {
        cout << "ReconstructShowers::   cmd_ALTP==9   ReconstructShowers_AG()   Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_AG();
    }
    else if   (cmd_ALTP==10) {
        cout << "ReconstructShowers::   cmd_ALTP==10   ReconstructShowers_GS()   Reconstruction of ParameterSet: "<< nr <<endl;
        ReconstructShowers_GS();
    }
 
    else if   (cmd_ALTP==999) {
        cout << "ReconstructShowers::   cmd_ALTP==9999  OpenMP TEST!!!!!"<<endl;
        ReconstructShowers_OPENMP();
    }
    //-----------------------------------
 
 
    //-----------------------------------
    if (TREE_ShowShower->GetEntries()<1) {
        cout << "//-----------------------------------------------------------------------------//"<<endl;
        cout << "   Hey Guy, I am so sorry, but NO , I repeat NO shower has been reconstructed!"<< endl;
        cout << "//-----------------------------------------------------------------------------//"<<endl;
    }
    cout << "TREE_ShowShower->GetEntries() = " << TREE_ShowShower->GetEntries()<< endl;
    //-----------------------------------
 
    //-----------------------------------
    // MakeShowerTree:
    // Writing showers in treebranch style
    // as done by FJ algorithm.
    //-----------------------------------
    FILE_ShowShower->cd();
    TREE_ShowShower->Write("",TObject::kOverwrite);
    //-----------------------------------
 
 
    //-----------------------------------
    // MakeTracksTree:
    // Writing showers in tracks style
    // copied almost verbatim from GL.
    //-----------------------------------
    cout << "Make Tracks Tree commented out!!!"<< endl;
    //-----------------------------------
 
 
    //-----------------------------------
    // Delete the ShowerOutputtree:
    delete TREE_ShowShower;
    TREE_ShowShower=0;
    //-----------------------------------
 
 
    return;
}

ReconstructShowers_AG()

void ReconstructShowers_AG

(

)

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_AG() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of "Advanced Gamma" Algorithm
    //-----------------------------------------------------------------
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check InitiatorBT
        // 2) compatible with a segment forming a e+e- pair:
        //-----------------------------------
        Int_t NPairs=0,PIDDIFF=0,minPIDDIFF=0;
 
        Int_t local_gAli_npat=local_gAli->Npatterns();
        Int_t btloop_cnt_N=0;
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
            btloop_cnt_N=local_gAli->GetPattern(patterloop_cnt)->GetN();
            if (local_gAli->GetPattern(patterloop_cnt)->Z()<InBT->Z()) continue;
            if (TMath::Abs(local_gAli->GetPattern(patterloop_cnt)->Z()-InBT->Z())>3000) continue;
            if (local_gAli->GetPattern(patterloop_cnt)->Z()<InBT->Z()) continue;
            for (Int_t btloop_cnt=0; btloop_cnt<btloop_cnt_N; ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
                if (IsSameSegment(seg,InBT)) continue;
                PIDDIFF=TMath::Abs(seg->PID()-InBT->PID());
                if (GetMinimumDist(InBT,seg)>50) continue;
                if (GetdR(InBT,seg)>200) continue;
                if (GetdeltaThetaSingleAngles(InBT,seg)>0.5) continue;
                if (PIDDIFF>minPIDDIFF) continue;
                //              cout << " GetMinimumDist(InBT,seg); " << GetMinimumDist(InBT,seg) << "PIDDIFF "<< PIDDIFF<< endl;
 
                AddBTToArrayWithCeck(seg, GLOBAL_ShowerSegArray);
                minPIDDIFF=PIDDIFF;
            }
        }
        PrintShowerObjectArray(GLOBAL_ShowerSegArray);
        //      return;
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
            btloop_cnt_N=local_gAli->GetPattern(patterloop_cnt)->GetN();
 
            // if pattern is before the Initiator BT->Z() position we just go on:
            if (local_gAli->GetPattern(patterloop_cnt)->Z()<InBT->Z()) continue;
 
            for (Int_t btloop_cnt=0; btloop_cnt<btloop_cnt_N; ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                // Now apply cut conditions: Advanced Gamma Alg  --------------------
                if (!GetConeOrTubeDistanceToBTOfShowerArray(seg, InBT, GLOBAL_ShowerSegArray, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                if (!FindPrecedingBTsSingleThetaAngle(seg, InBT, local_gAli, GLOBAL_ShowerSegArray)) continue;
                // end of    cut conditions: Advanced Gamma Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                //              if (IsSameSegment(seg,InBT)) { ; } // do nothing;
                //              else {GLOBAL_ShowerSegArray -> Add(seg);}
                AddBTToArrayWithCeck(seg, GLOBAL_ShowerSegArray);
            }
 
 
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
        }
        // end of loop over all plates of local_gAli
 
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
 
 
 
        Int_t s_NBT=0;
        Int_t s_NBTMC=0;
        Int_t s_NBTallMC=0;
        Int_t s_NBTeMC=0;
        Double_t  s_eff=0;
        Double_t s_purall=0;
        Double_t s_pure=0;
        CalcEffPurOfShower(GLOBAL_ShowerSegArray, s_NBT, s_NBTMC, s_NBTallMC, s_NBTeMC, s_purall, s_pure);
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

ReconstructShowers_BW()

void ReconstructShowers_BW

(

)

return; -----------------------------------------------------------------------—

return; -----------------------------------------------------------------------—

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_BW() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of "BackWard" Algorithm
    //-----------------------------------------------------------------
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    //-----------------------------------
    // Algorithm Iteration Steps:
    //
    //  0) Start Adjust Shower Axis, Virtual Vertex
    //  0) Calc dR/dT/dIP(trk,trk) to same plate.
    //  ---Loop up to firstplate;
    //  //  ---Loop for deltaN (plate)=1,2,3:
    // //   //  1) Calc dR/dT/dIP(trk,trk) to backward plate.
    // //   //  1) Check for already in shower array; add BT to shower
    // //   //  1) Adjust Shower Axis, Adjust Virtual Vertex
    //  //  ---Loop for deltaN (plate)=1,2,3:
    //  ---Loop up to firstplate;
    //  2) Adjust Shower Axis, Virtual Vertex.
    //
    //-----------------------------------
 
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    EdbSegP* segShower;
    EdbSegP* ShowerAxis;
    EdbVertex* VirtualVertex;
    Float_t local_gAli_pat_interim_halfsize=0;
    Double_t dR,dT,dminDist;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t show_NP=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL!=2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " (MCEvt=" << InBT->MCEvt() << ") now: "<<endl;
            InBT->PrintNice();
            cout << "InBT->P() " << InBT->P() << endl;
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec_BackWard(GLOBAL_gAli, InBT);
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        if (gEDBDEBUGLEVEL>2) cout << "--- TransformEdbPVRec done."<<endl;
        //-----------------------------------
 
 
        //-----------------------------------
        // 2) Start at plate for Initator BT:
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        Int_t btloop_cnt_N=0;
        //      if (gEDBDEBUGLEVEL>2)
        cout << "--- Starting BACKWARD Reco... ---" << endl;
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        Int_t patterloop_cnt_InBT=-1;
        Float_t patterloop_cnt_InBT_Z=0;
        for (Int_t patterloop_cnt=0; patterloop_cnt<local_gAli_npat; patterloop_cnt++) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
            // if pattern is after the Initiator BT->Z() position we stop:
            if (local_gAli->GetPattern(patterloop_cnt)->Z()<InBT->Z()) continue;
            patterloop_cnt_InBT=patterloop_cnt;
            patterloop_cnt_InBT_Z=local_gAli->GetPattern(patterloop_cnt)->Z();
        }
        if (gEDBDEBUGLEVEL>2) cout << "--- patterloop_cnt_InBT=  " << patterloop_cnt_InBT << endl;
        if (gEDBDEBUGLEVEL>2) cout << "--- patterloop_cnt_InBT_Z=  " << patterloop_cnt_InBT_Z << endl;
 
        // Check wich Steptype is needed for BackwardStepping:
        // Convention: -1 if Patter(0)_Z<Pattern(npat)_Z
        // Convention: +1 if Patter(0)_Z>Pattern(npat)_Z
        Int_t StepNr=0;
        if (gEDBDEBUGLEVEL>2) cout << "local_gAli->GetPattern(0)->Z()  " <<  local_gAli->GetPattern(0)->Z() << endl;
        if (gEDBDEBUGLEVEL>2) cout << "local_gAli->GetPattern(local_gAli_npat-1)->Z()  " <<  local_gAli->GetPattern(local_gAli_npat-1)->Z() << endl;
        if (local_gAli->GetPattern(0)->Z() > local_gAli->GetPattern(local_gAli_npat-1)->Z()) {
            StepNr=1;
        }
        else {
            StepNr=-1;
        }
        if (gEDBDEBUGLEVEL>2) cout << "--- StepNr for going backwards (decreasing Z) to next plate=  " << StepNr << endl;
 
        // return;
        Bool_t FP_reached=kFALSE;
        Int_t patterloop_cnt=patterloop_cnt_InBT;
        if (StepNr==1)  patterloop_cnt=patterloop_cnt_InBT;
        if (StepNr==-1)  cout << "DONT KNOW HERE WHICH    patterloop_cnt=local_gAli_npat-1;   to calculate!!! " << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        while (!FP_reached) {
            if (gEDBDEBUGLEVEL>2) cout << " FP NOT YET REACHED .... << doing patterloop_cnt = " << patterloop_cnt << endl;
            btloop_cnt_N=local_gAli->GetPattern(patterloop_cnt)->GetN();
            if (gEDBDEBUGLEVEL>2) cout << " FP NOT YET REACHED .... << with  btloop_cnt_N = " << btloop_cnt_N << endl;
 
            // Loop over all BTs in the actual plate. Calculate dR/dT/dIP to
            // all BTs which are already in the shower (at beginning it is
            // only the InBT.
            for (Int_t btloop_cnt=0; btloop_cnt<btloop_cnt_N; ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                Bool_t add_seg=kFALSE;
                if (gEDBDEBUGLEVEL>3) cout << "btloop_cnt (ot of ) " << btloop_cnt << "  ( "  << btloop_cnt_N << " ) " << endl;
 
                // Now apply cut conditions: BACKWARD Alg  --------------------
                // Check for dTheta to tracks already in shower:
                Int_t actualEntries=GLOBAL_ShowerSegArray->GetEntries();
                if (gEDBDEBUGLEVEL>3) cout << "actualEntries of  GLOBAL_ShowerSegArray:  " << actualEntries << endl;
                for (int i=0; i<actualEntries; ++i) {
                    segShower=(EdbSegP*)GLOBAL_ShowerSegArray->At(i);
                    Float_t dZ=TMath::Abs(segShower->Z()-seg->Z());
                    dT=GetdeltaThetaSingleAngles(seg,segShower); // DO NOT TAKE GetdeltaTheta since this is calculation based on absolute theta differences (not on TX,TY relative ones) !!
                    dR=GetdR(seg,segShower);
                    dminDist=GetMinimumDist(seg,segShower);
                    if (gEDBDEBUGLEVEL>3) cout << "btloop_cnt i  dT  dR  dminDist dZ: " << btloop_cnt << "  " << i << "  " << dT << "  " << dR << "  " << dminDist << "  " << dZ << endl;
                    if (TMath::Abs(dZ)>CUT_PARAMETER[3]) continue;
                    if (TMath::Abs(dT)>CUT_PARAMETER[1]) continue;
                    if (TMath::Abs(dR)>CUT_PARAMETER[2]) continue;
                    if (TMath::Abs(dminDist)>CUT_PARAMETER[0]) continue;
                    if (gEDBDEBUGLEVEL>3) cout << "try to add this BT (if not already in there...) "<< endl;
                    add_seg=kTRUE;
                    break;
                } // of for (int i=0; i<actualEntries; ++i)
                if (add_seg) {
                    AddBTToArrayWithCeck(seg,GLOBAL_ShowerSegArray);
                    EdbSegP* BT_1=(EdbSegP*)GLOBAL_ShowerSegArray->At(0);
                    EdbSegP* BT_2=(EdbSegP*)GLOBAL_ShowerSegArray->At(GLOBAL_ShowerSegArray->GetEntries()-1);
                    show_NP=TMath::Max(show_NP,TMath::Abs(BT_1->PID()-BT_2->PID())+1);
                    //cout << "show_NP = " << show_NP << endl;
                }
            } // of for (Int_t btloop_cnt=0; btloop_cnt<btloop_cnt_N; ++btloop_cnt)
 
            // Now goto next plate:
            patterloop_cnt=patterloop_cnt+StepNr;
            if (patterloop_cnt<0) FP_reached=kTRUE;
            if (patterloop_cnt>=local_gAli_npat) FP_reached=kTRUE;
            // Or we stop also if the number of plates is more than cmd_NP
            if (show_NP>=cmd_NP) FP_reached=kTRUE;
        } // while (!FP_reached)
 
 
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  purall, pure;
            CalcEffPurOfShower(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure);
            GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[i];
            GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[i];
            GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[i];
            GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[i];
            GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[i];
        }
 
        if (gEDBDEBUGLEVEL>2) cout << " Check if its sorted: GLOBAL_ShowerSegArray->At(0)->Z() should be the lowest one...continue;" << endl;
        if (gEDBDEBUGLEVEL>2) cout << " IsShowerSortedZ(GLOBAL_ShowerSegArray)  " << IsShowerSortedZ(GLOBAL_ShowerSegArray) << endl;
        SortShowerZ(GLOBAL_ShowerSegArray);
 
        // After Sort Shower we can build axis right now...
        ShowerAxis=BuildShowerAxis(GLOBAL_ShowerSegArray);
        ShowerAxis->PrintNice();
        Float_t mindTTT=999999;
        Int_t mindTTT_h=0;
        for (int h=0; h<GLOBAL_ShowerSegArray->GetEntries(); ++h) {
            segShower=(EdbSegP*)GLOBAL_ShowerSegArray->At(h);
            //      segShower->PrintNice();
            if (segShower->Z()!=ShowerAxis->Z()) continue;
            Float_t dTTT = GetdeltaTheta(ShowerAxis,segShower); //cout << "dTTT  = " << dTTT << endl;
            if (dTTT<mindTTT) {
                mindTTT=dTTT;
                mindTTT_h=h;
            }
        }
 
        // Now here comes the forward (==downstream==inbeamdirection) reconstruction
        if (gEDBDEBUGLEVEL>2) cout << "--- Starting FORWARD Reco... ---" << endl;
 
        // Just take the BT which is closest to shower axis:
        ShowerAxis=(EdbSegP*)GLOBAL_ShowerSegArray->At(mindTTT_h);
        GLOBAL_ShowerSegArray->Clear();
        // The First we have to add by hand because in the reco routine there has to be at least one BT to check.
        GLOBAL_ShowerSegArray->Add(ShowerAxis);
        if (gEDBDEBUGLEVEL>3) ShowerAxis->PrintNice();
 
        for (Int_t patterloop_cnt=0; patterloop_cnt<local_gAli_npat; patterloop_cnt++) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
            // if pattern is after the ShowerAxis BT->Z() position we stop:
            if (local_gAli->GetPattern(patterloop_cnt)->Z()<ShowerAxis->Z()) continue;
            patterloop_cnt_InBT=patterloop_cnt;
            patterloop_cnt_InBT_Z=local_gAli->GetPattern(patterloop_cnt)->Z();
        }
        if (gEDBDEBUGLEVEL>2) cout << "--- patterloop_cnt_InBT=  " << patterloop_cnt_InBT << endl;
        if (gEDBDEBUGLEVEL>2) cout << "--- patterloop_cnt_InBT_Z=  " << patterloop_cnt_InBT_Z << endl;
 
        // InvertSpeNr now for forward Step:
        Int_t StepNrForward=StepNr*-1;
        StepNr=StepNrForward;
        show_NP=0;
 
        Bool_t LP_reached=kFALSE;
        patterloop_cnt=patterloop_cnt_InBT;
 
        while (!LP_reached) {
            if (gEDBDEBUGLEVEL>2) cout << " LP NOT YET REACHED .... << doing patterloop_cnt = " << patterloop_cnt << endl;
            btloop_cnt_N=local_gAli->GetPattern(patterloop_cnt)->GetN();
            if (gEDBDEBUGLEVEL>2) cout << " LP NOT YET REACHED .... << with  btloop_cnt_N = " << btloop_cnt_N << endl;
 
            // Loop over all BTs in the actual plate. Calculate dR/dT/dIP to
            // all BTs which are already in the shower (at beginning it is
            // only the InBT.
            for (Int_t btloop_cnt=0; btloop_cnt<btloop_cnt_N; ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
                Bool_t add_seg=kFALSE;
                if (gEDBDEBUGLEVEL>3) cout << "btloop_cnt (ot of ) " << btloop_cnt << "  ( "  << btloop_cnt_N << " ) " << endl;
 
                // Now apply cut conditions: BACKWARD Alg  --------------------
                // Check for dTheta to tracks already in shower:
                Int_t actualEntries=GLOBAL_ShowerSegArray->GetEntries();
                if (gEDBDEBUGLEVEL>3) cout << "actualEntries of  GLOBAL_ShowerSegArray:  " << actualEntries << endl;
                for (int i=0; i<actualEntries; ++i) {
                    segShower=(EdbSegP*)GLOBAL_ShowerSegArray->At(i);
                    Float_t dZ=TMath::Abs(segShower->Z()-seg->Z());
                    dT=GetdeltaThetaSingleAngles(seg,segShower); // DO NOT TAKE GetdeltaTheta since this is calculation based on absolute theta differences (not on TX,TY relative ones) !!
                    dR=GetdR(seg,segShower);
                    dminDist=GetMinimumDist(seg,segShower);
                    if (gEDBDEBUGLEVEL>3) cout << "btloop_cnt i  dT  dR  dminDist dZ: " << btloop_cnt << "  " << i << "  " << dT << "  " << dR << "  " << dminDist << "  " << dZ << endl;
                    if (TMath::Abs(dZ)>CUT_PARAMETER[7]) continue;
                    if (TMath::Abs(dT)>CUT_PARAMETER[5]) continue;
                    if (TMath::Abs(dR)>CUT_PARAMETER[6]) continue;
                    if (TMath::Abs(dminDist)>CUT_PARAMETER[4]) continue;
                    if (gEDBDEBUGLEVEL>3) cout << "try to add this BT (if not already in there...) "<< endl;
                    add_seg=kTRUE;
                    break;
                } // of for (int i=0; i<actualEntries; ++i)
                if (add_seg) {
                    AddBTToArrayWithCeck(seg,GLOBAL_ShowerSegArray);
                    EdbSegP* BT_1=(EdbSegP*)GLOBAL_ShowerSegArray->At(0);
                    EdbSegP* BT_2=(EdbSegP*)GLOBAL_ShowerSegArray->At(GLOBAL_ShowerSegArray->GetEntries()-1);
                    show_NP=TMath::Max(show_NP,TMath::Abs(BT_1->PID()-BT_2->PID())+1);
                    //cout << "show_NP = " << show_NP << endl;
                }
            } // of for (Int_t btloop_cnt=0; btloop_cnt<btloop_cnt_N; ++btloop_cnt)
 
 
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Now goto next plate:
            patterloop_cnt=patterloop_cnt+StepNr;
            if (patterloop_cnt<0) LP_reached=kTRUE;
            if (patterloop_cnt>=local_gAli_npat) LP_reached=kTRUE;
            // Or we stop also if the number of plates is more than cmd_NP
            if (show_NP>=cmd_NP) LP_reached=kTRUE;
 
        } // of while (!LP_reached)
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

ReconstructShowers_CA()

void ReconstructShowers_CA

(

)

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_CA() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of ConeAdvanced Algorithm
    //-----------------------------------------------------------------
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
    cout << "GLOBAL_InBTArrayEntries = " << GLOBAL_InBTArrayEntries << endl;
 
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        if (gEDBDEBUGLEVEL==1) {
            int modulo=GLOBAL_InBTArrayEntries/20;
            if ((i%modulo)==0) cout << i <<" : 5% more done"<<endl;
        }
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
            for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                // Now apply cut conditions: CA ConeAdvanced Alg  --------------------
                if (!GetConeOrTubeDistanceToInBT(seg, InBT, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                if (!FindPrecedingBTs(seg, InBT, local_gAli, GLOBAL_ShowerSegArray)) continue;
                // end of    cut conditions: CA ConeAdvanced Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                if (seg->X()==InBT->X()&&seg->Y()==InBT->Y()) {
                    ;    // do nothing;
                }
                else {
                    GLOBAL_ShowerSegArray -> Add(seg);
                }
            }
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
        }
        // end of loop over all plates of local_gAli
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

ReconstructShowers_CL()

void ReconstructShowers_CL

(

)

=== DEBUG===

===END DEBUG===

===DEBUG===

====== DEBUG===

===END DEBUG===

if (sa->X()<LeftX || sa->X()>RightX || sa->Y()<LeftY || sa->Y()>RightY) continue; /// DEBUG

–val_tan; // Project the last on beack to its owns

---

==== Now loop over the Grouped plates and search for spectrum peaks in each groupedPlate...

Set the bin arrays for the Spectrum...

---

Fit each grouped Plate with Spectrum...

---

.------------—

Fill interimSpectrum For Drawing... without the THRESHOLD_SMOOTHED_DEST Cut to find Maximum

Fill interimSpectrum For Drawing...only when Entry is > THRESHOLD_SMOOTHED_DEST * Maximum THRESHOLD_SMOOTHED_DEST is in % Units of Maxium...

end of loop over the Grouped plates

=== DEBUG===

===END DEBUG===

===DEBUG===

====== DEBUG===

===END DEBUG===

if (sa->X()<LeftX || sa->X()>RightX || sa->Y()<LeftY || sa->Y()>RightY) continue; /// DEBUG

–val_tan; // Project the last on beack to its owns

---

==== Now loop over the Grouped plates and search for spectrum peaks in each groupedPlate...

Set the bin arrays for the Spectrum...

---

Fit each grouped Plate with Spectrum...

---

.------------—

Fill interimSpectrum For Drawing... without the THRESHOLD_SMOOTHED_DEST Cut to find Maximum

Fill interimSpectrum For Drawing...only when Entry is > THRESHOLD_SMOOTHED_DEST * Maximum THRESHOLD_SMOOTHED_DEST is in % Units of Maxium...

end of loop over the Grouped plates

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_CL() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of CLuster Algorithm
    //-----------------------------------------------------------------
    //
    // For each InitiatorBT this is
    // divided in several small parts:
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    //-----------------------------------
    //      0)      Predefinitions
    //-----------------------------------
 
    // Set ClusterBoxSize of X,Y in microns: (f.e. 50x50)
    Float_t BOXSIZE=50;
    Float_t ClusterBoxSizeX=BOXSIZE;
    Float_t ClusterBoxSizeY=ClusterBoxSizeX;
    Float_t ClusterBoxSize[]= {ClusterBoxSizeX,ClusterBoxSizeY};
 
    // Set GLOBAL Boundaries of the BrickSize, depends on your MC Simulation and on your scanned BG size
    // Later we will set the frame size, which can be f.e. 1mmX1mm, 3mmX3mm ...
    // This does not need to be changed...
    Float_t LeftX=-11000;
    Float_t RightX=21000;
    Float_t LeftY=-11000;
    Float_t RightY=16000;
 
    cout << " ......."<<endl;
    // Set SquareSize of The gAliSub -> Coorseponds to the totral scan Area:
    Float_t VIEWSIZE=1000;
    Float_t gAliSub_Length_X=VIEWSIZE;
    Float_t gAliSub_Length_Y=VIEWSIZE; //1mm
 
    // Calculate how many NbinsX,Y are needed:
    Int_t NbinsX=Int_t((RightX-LeftX)/ClusterBoxSizeX);
    Int_t NbinsY=Int_t((RightY-LeftY)/ClusterBoxSizeY);
 
 
    cout << " ......."<<endl;
 
    Int_t NPLATES=GLOBAL_gAli->Npatterns();
    Int_t NbinsZ=NPLATES;
 
    // Calculate how many NbinsX,Y are needed:
    Int_t NbinsX_gAliSub=Int_t((gAliSub_Length_X)/ClusterBoxSizeX);
    Int_t NbinsY_gAliSub=Int_t((gAliSub_Length_Y)/ClusterBoxSizeY);
 
    // Arrays for the Spectrum source and dests...
    Float_t ** source = new float *[NbinsX];
    for (Int_t cnti=0; cnti<NbinsX; cnti++) {
        source[cnti]=new float[NbinsY];
    }
    Float_t ** dest = new float *[NbinsX];
    for (Int_t cnti=0; cnti<NbinsX; cnti++) {
        dest[cnti]=new float[NbinsY];
    }
 
    // Arrays for the Spectrum source and dests...
    Float_t ** source_gAliSub = new float *[NbinsX_gAliSub];
    for (Int_t cnti=0; cnti<NbinsX_gAliSub; cnti++) {
        source_gAliSub[cnti]=new float[NbinsY_gAliSub];
    }
    Float_t ** dest_gAliSub = new float *[NbinsX_gAliSub];
    for (Int_t cnti=0; cnti<NbinsX_gAliSub; cnti++) {
        dest_gAliSub[cnti]=new float[NbinsY_gAliSub];
    }
 
    // Fil Exptrapoalted BT with direction into next plate?
    Bool_t FillTANData=kTRUE;
    cout << " ......."<<endl;
 
    // Plates to be grouped Together:
    Int_t       PLATESPERGROUP=1;
    Int_t   FIRSTPLATE=0;
    Int_t LASTPLATE=0;
    Int_t   MAXPLATE=GLOBAL_gAli->Npatterns()-1;
    Int_t NGroupedPLATES=ceil( (Double_t)NPLATES/(Double_t)PLATESPERGROUP);
 
    // Spectrum Position Peaks
    Float_t* fPositionX;
    Float_t* fPositionY;
    Int_t fNPeaks;
 
    // Start Position...
    Float_t StartPosX,StartPosY,StartPosTX,StartPosTY;
 
    // Calculate the z-positions for the grouped plates:
    Float_t ZPosGroupedPlates[50];
    cout << "gAli->GetPattern(firstplate)->GetSegment(0)->Z;  "<<GLOBAL_gAli->GetPattern(0)->Z()<<endl;
    cout << "gAli->GetPattern(lastplate)->GetSegment(0)->Z;  "<<GLOBAL_gAli->GetPattern(GLOBAL_gAli->Npatterns()-1)->Z()<<endl;
 
    for (Int_t i=0; i<NGroupedPLATES; i++) {
        ZPosGroupedPlates[i]=GLOBAL_gAli->GetPattern(0)->Z()+PLATESPERGROUP*1300*i;
        cout << "i PLATESPERGROUP NGroupedPLATES ZPosGroupedPlates[i] " << i << " " <<  PLATESPERGROUP << " " << NGroupedPLATES  << " " << ZPosGroupedPlates[i] << " " << endl;
    }
 
    if (gEDBDEBUGLEVEL==2) {
        cout << "NbinsX = " << NbinsX << endl;
        cout << "NbinsY = " << NbinsY << endl;
        cout << "NbinsZ = " << NbinsZ << endl;
        cout << "NbinsX_gAliSub = " << NbinsX_gAliSub << endl;
        cout << "NbinsY_gAliSub = " << NbinsY_gAliSub << endl;
        cout << "FIRSTPLATE=  "<<FIRSTPLATE<<endl;
        cout << "LASTPLATE=  "<<LASTPLATE<<endl;
        cout << "MAXPLATE=  "<<MAXPLATE<<endl;
        cout << "NPLATES=  "<<NPLATES<<endl;
        cout << "NGroupedPLATES=  "<<NGroupedPLATES<<endl;
        cout << "PLATESPERGROUP=  "<<PLATESPERGROUP<<endl;
    }
 
    //=========================================
    // Create the 2Dim  Histograms:
    Reco_CL_BuildGlobalHistogramsOnHeap();
    // Create the 2Dim  Histograms:
    Hist2DimOnlyBGAllPlates= new TH2F();
    Hist2DimOnlySimOneEventAllPlates= new TH2F();
    Hist2DimBGAndSimOneEventAllPlates= new TH2F();
    // Create the 3Dim  Histograms:
    Hist3DimOnlyBG = new TH3F();
    Hist3DimRecoEvent_gAli = new TH3F();
    //=========================================
    // Allocate TSectrum2 pointer on the heap, and try to speed up program....
    spectrum2dim= new TSpectrum2();
    spectrum2dim->Print();
    //=========================================
 
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
    cout << "GLOBAL_InBTArrayEntries = " << GLOBAL_InBTArrayEntries << endl;
 
    TClonesArray    *as;
    EdbSegP     *sa;
    EdbPattern  *as_pattern;
    EdbPattern  *as_pattern_sub;
 
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    //   for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=GLOBAL_InBTArrayEntries-1; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        if (gEDBDEBUGLEVEL==1) {
            int modulo=GLOBAL_InBTArrayEntries/20;
            if ((i%modulo)==0) cout << i <<" : 5% more done"<<endl;
        }
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
        //-----------------------------------
        // 1a) Set Some Variables
        //-----------------------------------
        StartPosX=InBT->X();
        StartPosY=InBT->Y();
        StartPosTX=InBT->TX();
        StartPosTY=InBT->TY();
        //-----------------------------------
 
        //-----------------------------------
        //  1b) Now SetBins for the 2D, 3D Histograms for THIS (specific) Event
        //-----------------------------------
 
        cout << "Reset now some other histos"<<endl;
        for (Int_t h=0; h<50; h++) {
            Hist2DimOnlyBGOneGroupedPlate[h]->Reset();
            Hist2DimOnlySimOneEventOneGroupedPlate[h]->Reset();
            Hist2DimBGAndSimOneEventOneGroupedPlate[h]->Reset();
        }
 
        cout << "Reset now some other SetNameTitle "<<endl;
        Hist2DimOnlyBGAllPlates->SetNameTitle("Hist2DimOnlyBGAllPlates","Hist2DimOnlyBGAllPlates");
        Hist2DimOnlySimOneEventAllPlates->SetNameTitle("Hist2DimOnlySimOneEventAllPlates","Hist2DimOnlySimOneEventAllPlates");
        Hist2DimBGAndSimOneEventAllPlates->SetNameTitle("Hist2DimBGAndSimOneEventAllPlates","Hist2DimBGAndSimOneEventAllPlates");
        Hist2DimOnlyBGAllPlates->SetBins(  NbinsX_gAliSub, StartPosX-gAliSub_Length_X/2.0, StartPosX +gAliSub_Length_X/2.0, NbinsY_gAliSub, StartPosY-gAliSub_Length_Y/2.0, StartPosY +gAliSub_Length_Y/2.0);
        Hist2DimOnlySimOneEventAllPlates->SetBins(  NbinsX_gAliSub, StartPosX-gAliSub_Length_X/2.0, StartPosX +gAliSub_Length_X/2.0, NbinsY_gAliSub, StartPosY-gAliSub_Length_Y/2.0, StartPosY +gAliSub_Length_Y/2.0);
        Hist2DimBGAndSimOneEventAllPlates->SetBins(  NbinsX_gAliSub, StartPosX-gAliSub_Length_X/2.0, StartPosX +gAliSub_Length_X/2.0, NbinsY_gAliSub, StartPosY-gAliSub_Length_Y/2.0, StartPosY +gAliSub_Length_Y/2.0);
 
        cout << "Reset now some other SetNameTitle "<<endl;
        Hist3DimOnlyBG->SetNameTitle("Hist3DimOnlyBG","Hist3DimOnlyBG");
        Hist3DimOnlyBG->SetBins( NbinsX_gAliSub, StartPosX -gAliSub_Length_X/2.0, StartPosX +gAliSub_Length_X/2.0, NbinsY_gAliSub, StartPosY -gAliSub_Length_Y/2.0, StartPosY +gAliSub_Length_Y/2.0, NGroupedPLATES, (FIRSTPLATE-1)*1300, NbinsZ*1300);
        Hist3DimRecoEvent_gAli->SetNameTitle("Hist3DimRecoEvent_gAli","Hist3DimRecoEvent_gAli");
        Hist3DimRecoEvent_gAli->SetBins( NbinsX, LeftX, RightX, NbinsY, LeftY, RightY, NGroupedPLATES, (FIRSTPLATE-1)*1300, (LASTPLATE)*1300);
 
        cout << "Reset now some other SetNameTitle "<<endl;
        Hist2DimOnlyBGAllPlates->Reset();
        Hist2DimOnlySimOneEventAllPlates->Reset();
        Hist2DimBGAndSimOneEventAllPlates->Reset();
        Hist3DimOnlyBG->Reset();
        Hist3DimRecoEvent_gAli->Reset();
 
        //-----------------------------------
        // 1c) Define the Histograms Bounds and Bins,
        // 1c) Since Bounds are depending on h ...
        //-----------------------------------
        Float_t InBT_X=InBT->X();
        Float_t InBT_TX=InBT->TX();
        Float_t InBT_X_Extrapolated;
        Float_t InBT_Y=InBT->Y();
        Float_t InBT_TY=InBT->TY();
        Float_t InBT_Y_Extrapolated;
        Float_t InBT_Z=InBT->Z();
        for (Int_t h=0; h<NGroupedPLATES; h++) {
            //cout << "--------------------"<<endl;
            Float_t zdiff=ZPosGroupedPlates[h]-InBT_Z;
            InBT_X_Extrapolated=InBT_X+InBT_TX*zdiff;
            InBT_Y_Extrapolated=InBT_Y+InBT_TY*zdiff;
            cout << "h InBT_X InBT_TX InBT_Z ZPosGroupedPlates[h] zdiff  InBT_X_Extrapolated " << h << " " <<  InBT_X << " " << InBT_TX << " " << InBT_Z << " " << ZPosGroupedPlates[h] << " " << zdiff << " " <<InBT_X_Extrapolated << endl;
            cout << "h InBT_Y InBT_TY InBT_Z ZPosGroupedPlates[h] zdiff  InBT_Y_Extrapolated " << h << " " <<  InBT_Y << " " << InBT_TY << " " << InBT_Z << " " << ZPosGroupedPlates[h] << " " << zdiff << " " <<InBT_Y_Extrapolated << endl;
            Hist2DimOnlyBGOneGroupedPlate[h]->SetBins(NbinsX_gAliSub, InBT_X_Extrapolated-gAliSub_Length_X/2.0,InBT_X_Extrapolated+gAliSub_Length_X/2.0, NbinsY_gAliSub,InBT_Y_Extrapolated-gAliSub_Length_Y/2.0,InBT_Y_Extrapolated+gAliSub_Length_Y/2.0);
            Hist2DimOnlySimOneEventOneGroupedPlate[h]->SetBins(NbinsX_gAliSub, InBT_X_Extrapolated-gAliSub_Length_X/2.0,InBT_X_Extrapolated+gAliSub_Length_X/2.0, NbinsY_gAliSub,InBT_Y_Extrapolated-gAliSub_Length_Y/2.0,InBT_Y_Extrapolated+gAliSub_Length_Y/2.0);
            Hist2DimBGAndSimOneEventOneGroupedPlate[h]->SetBins(NbinsX_gAliSub, InBT_X_Extrapolated-gAliSub_Length_X/2.0,InBT_X_Extrapolated+gAliSub_Length_X/2.0, NbinsY_gAliSub,InBT_Y_Extrapolated-gAliSub_Length_Y/2.0,InBT_Y_Extrapolated+gAliSub_Length_Y/2.0);
        }
        //=========================================
 
 
 
        //-----------------------------------
        // 1c) Loop over (whole) local_gAli, Fill the Histograms  (from firstplate up to lastplate)
        //-----------------------------------
        Int_t val, val_tan;
        Int_t local_gAli_npat=local_gAli->Npatterns();
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
            as = (TClonesArray*)local_gAli->GetPattern(patterloop_cnt)->GetSegments();
            as_pattern= (EdbPattern*)local_gAli->GetPattern(patterloop_cnt);
 
            cout << "===DEBUG   patterloop_cnt=  " << patterloop_cnt << "   Z pos (k) " << local_gAli->GetPattern(patterloop_cnt)->Z() << endl;  // get Z pos of the plate k
            cout << "===DEBUG   (patterloop_cnt) EdbSegments in the Pattern (total): " << as->GetEntries() << endl;
 
            for (Int_t h=0; h<as->GetEntries(); h++) {
                sa = (EdbSegP*)( as->At(h) );
                val=Reco_CL_AssignZValueToGroup(sa->Z(), ZPosGroupedPlates[0], NGroupedPLATES, PLATESPERGROUP);
                cout << "entry, val  "<<h << "  "  << val<<endl;
                Hist2DimBGAndSimOneEventOneGroupedPlate[val]->Fill(sa->X(),sa->Y());
                if (sa->MCEvt()<0) Hist2DimOnlyBGOneGroupedPlate[val]->Fill(sa->X(),sa->Y());
                if (FillTANData) {
                    val_tan=Reco_CL_AssignZValueToGroup(sa->Z()+1300, ZPosGroupedPlates[0], NGroupedPLATES, PLATESPERGROUP);
                    cout << "(TAN) entry, val_tan  "<<h << "  "  << val_tan<<endl;
                    if (val_tan>=NGroupedPLATES) {
                        ++val_tan; // Project the last on beack to its owns
                        cout << "(TAN) val_tan changed to "<<h << "  "  << val_tan<<endl;
                    }
                    Hist2DimBGAndSimOneEventOneGroupedPlate[val_tan]->Fill(sa->X()+sa->TX()*1300,sa->Y()+sa->TY()*1300);
                    if (sa->MCEvt()<0) Hist2DimOnlyBGOneGroupedPlate[val_tan]->Fill(sa->X()+sa->TX()*1300,sa->Y()+sa->TY()*1300);
                }
                if (sa->MCEvt()<0) continue;
                if (sa->MCEvt()!=GLOBAL_InBT_MC) continue;
                cout << "===   ==DEBUG   Filling i with MCEvt  "<< i <<"("<< GLOBAL_InBT_MC <<")  X,Y,Z: "<<sa->X()<<" "<<sa->Y()<<" "<<sa->Z()<<"  "<<sa->MCEvt()<< "   to val= " <<val <<endl;
                Hist2DimOnlySimOneEventOneGroupedPlate[val]->Fill(sa->X(),sa->Y());
                if (FillTANData) {
                    Hist2DimOnlySimOneEventOneGroupedPlate[val_tan]->Fill(sa->X()+sa->TX()*1300,sa->Y()+sa->TY()*1300);
                }
            }
 
        } //of Loop over all plates of local_gAli,
 
 
        cout<<endl<<endl;
        cout <<"Loop over the Grouped plates and search for spectrum peaks in each groupedPlate."<<endl;
        for (Int_t h=0; h<NGroupedPLATES; h++) {
 
            for (Int_t cnti = 0; cnti < NbinsX_gAliSub; cnti++) {
                for (Int_t cntj = 0; cntj < NbinsY_gAliSub; cntj++) {
                    source[cnti][cntj] = 0; // Reset source before filling it new...
                    dest[cnti][cntj] = 0; // Reset dest before filling it new...
                    source[cnti][cntj] = Hist2DimBGAndSimOneEventOneGroupedPlate[h]->GetBinContent(cnti + 1,cntj + 1);
                }
            }
            Int_t nfound=0;
            cout << " Do now peak search..."<<endl;
            nfound = spectrum2dim->SearchHighRes(source, dest, NbinsX_gAliSub, NbinsY_gAliSub, 2, 20, kTRUE, 10, kFALSE, 5);// TO BE OPTIMIZED...
            cout << " Peak search finished. Go on."<<endl;
            spectrum_interim=(TH2F*)Hist2DimBGAndSimOneEventOneGroupedPlate[h]->Clone();
            spectrum_interim->Reset();
            Int_t interimsbin=0;
            TAxis *xax;
            TAxis *yax;
            TAxis *zax;
            Double_t xax_bin_value;
            Double_t yax_bin_value;
            Double_t zax_bin_value;
            Double_t value;
 
            for (Int_t ii = 0; ii < NbinsX_gAliSub; ii++) {
                for (Int_t jj = 0; jj < NbinsY_gAliSub; jj++) {
                    value=dest[ii][jj];
                    spectrum_interim->SetBinContent(ii + 1,jj + 1, value);
                }
            }
            Float_t THRESHOLD_SMOOTHED_DEST=0.5;
            cout << "THRESHOLD_SMOOTHED_DEST  spectrum_interim->GetMaximum()  : " << THRESHOLD_SMOOTHED_DEST << "  " << spectrum_interim->GetMaximum()<< endl;
            cout << "----------_"<<endl;
 
            Double_t spec_int_maximum=spectrum_interim->GetMaximum();
 
            for (Int_t ii = 0; ii < NbinsX_gAliSub; ii++) {
                for (Int_t jj = 0; jj < NbinsY_gAliSub; jj++) {
                    // cout << " h ii jj THRESHOLD_SMOOTHED_DEST dest[ii][jj] "<< h << " " <<  ii << "  " << jj << "  " << THRESHOLD_SMOOTHED_DEST  << "  " << dest[ii][jj] << endl;
                    if (dest[ii][jj]<THRESHOLD_SMOOTHED_DEST*spec_int_maximum) continue;
                    value=dest[ii][jj];
                    spectrum_interim->SetBinContent(ii + 1,jj + 1, value);
                    xax_bin_value=spectrum_interim->GetXaxis()->GetBinCenter(ii + 1);
                    yax_bin_value=spectrum_interim->GetYaxis()->GetBinCenter(jj + 1);
                    zax_bin_value=ZPosGroupedPlates[h];
                    //                  cout <<" xax_bin   ii jj (xyz) value  "<<  xax_bin_value  << "  " <<  ii <<  "  " << jj<< "  " <<xax_bin_value  << "  " << yax_bin_value<< "  " << zax_bin_value<<"    " << value << endl;
                    Hist3DimRecoEvent_gAli->Fill(xax_bin_value,yax_bin_value,zax_bin_value, value);
                }
            }
            cout << "THRESHOLD_SMOOTHED_DEST  spectrum_interim->GetMaximum()  : " << THRESHOLD_SMOOTHED_DEST << "  " << spectrum_interim->GetMaximum()<< endl;
            cout << "----------_"<<endl;
 
            //AllGroupsSimPlusBGittedSpectrum->cd(h+1);
            //spectrum_interim->DrawCopy("colz");
        }
 
 
 
 
 
        return;
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        //     Int_t local_gAli_npat=local_gAli->Npatterns();
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
            for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                // Now apply cut conditions: CT ConeTube Alg  --------------------
                if (!GetConeOrTubeDistanceToInBT(seg, InBT, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                if (!FindPrecedingBTs(seg, InBT, local_gAli, GLOBAL_ShowerSegArray)) continue;
                // end of    cut conditions: CT ConeTube Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                if (seg->X()==InBT->X()&&seg->Y()==InBT->Y()) {
                    ;    // do nothing;
                }
                else {
                    GLOBAL_ShowerSegArray -> Add(seg);
                }
            }
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
        }
        // end of loop over all plates of local_gAli
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

ReconstructShowers_CT()

void ReconstructShowers_CT

(

)

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_CT() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of ConeTube Algorithm
    //-----------------------------------------------------------------
    //
    // For each InitiatorBT this is
    // divided in several small parts:
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
    cout << "GLOBAL_InBTArrayEntries = " << GLOBAL_InBTArrayEntries << endl;
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        if (gEDBDEBUGLEVEL==1) {
            int modulo=GLOBAL_InBTArrayEntries/20;
            if ((i%modulo)==0) cout << i <<" : 5% more done"<<endl;
        }
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
            for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                // Now apply cut conditions: CT ConeTube Alg  --------------------
                if (!GetConeOrTubeDistanceToInBT(seg, InBT, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                if (!FindPrecedingBTs(seg, InBT, local_gAli, GLOBAL_ShowerSegArray)) continue;
                // end of    cut conditions: CT ConeTube Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                if (seg->X()==InBT->X()&&seg->Y()==InBT->Y()) {
                    ;    // do nothing;
                }
                else {
                    GLOBAL_ShowerSegArray -> Add(seg);
                }
            }
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
        }
        // end of loop over all plates of local_gAli
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

ReconstructShowers_GS()

void ReconstructShowers_GS

(

)

============================================================================================

======================== CODE FROM EdbShowAlg_GS FROM libShowRec =========================

Change with respect to libShowRec: here we assume that Segment will always be the Initiator BaseTrack and Segment2 is the other segment to check.

Segment = (EdbSegP*)pat_one->GetSegment(pat_one_bt_cnt); Segment = InBT; Change with respect to libShowRec: here we assume that Segment will always be the Initiator BaseTrack.

At first: Check for already duplicated pairings: if (CheckPairDuplications(Segment->PID(),Segment->ID(),Segment2->PID(),Segment2->ID(), SegmentPIDArray,SegmentIDArray,Segment2PIDArray,Segment2IDArray, RecoShowerArrayN)) continue;

if (IsPossibleFakeDoublet(Segment,Segment2) ) continue;

============================================================================================

============================================================================================

---

ONLY FOR THE ANN TRAINING FOR GS ALGO: DO THIS ONLY IF YOU HAVE PAIRS !!!

---

============================================================================================

======================== CODE FROM EdbShowAlg_GS FROM libShowRec =========================

Change with respect to libShowRec: here we assume that Segment will always be the Initiator BaseTrack and Segment2 is the other segment to check.

Segment = (EdbSegP*)pat_one->GetSegment(pat_one_bt_cnt); Segment = InBT; Change with respect to libShowRec: here we assume that Segment will always be the Initiator BaseTrack.

At first: Check for already duplicated pairings: if (CheckPairDuplications(Segment->PID(),Segment->ID(),Segment2->PID(),Segment2->ID(), SegmentPIDArray,SegmentIDArray,Segment2PIDArray,Segment2IDArray, RecoShowerArrayN)) continue;

if (IsPossibleFakeDoublet(Segment,Segment2) ) continue;

============================================================================================

============================================================================================

---

ONLY FOR THE ANN TRAINING FOR GS ALGO: DO THIS ONLY IF YOU HAVE PAIRS !!!

---

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_GS() ---");
    //-----------------------------------------------------------------
    // Main function for reconstruction of "Gamma Search" Algorithm
    //-----------------------------------------------------------------
 
 
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, search and check BT pairs for suts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
 
    Bool_t IsFirstLoopCount=kTRUE;
    Int_t LastGlobalMCEventNr=1;
 
    EdbVertex* vtx=new EdbVertex();
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
 
 
        //-----------------------------------
        // 0) Set vtx according to MC event,
        //    or to a half plate backward propagated segment.
        //    Do this only if the value -GBMC is NOT set,
        //    (in the case -GBMC is set, we should know the vertex anyway).
        //-----------------------------------
        //
        if (GLOBAL_InBT_MC>LastGlobalMCEventNr) LastGlobalMCEventNr=GLOBAL_InBT_MC;
        //
        //
        if (GLOBAL_InBT_MC<0&& cmd_GBMC<0) {
            // This is an "equalization" effect. If we dont put this in, we will have BG base
            // tracks always extrapolated to themselves, but SIM basetracks extrapolated to
            // the vertex. This leads to a wrong deltaZ distribution which spoils the
            // ANN Training.
            if( IsFirstLoopCount==kTRUE) cout << "Option: GLOBAL_InBT_MC<0&& cmd_GBMC<0"<<endl;
            vtx->SetXYZ(GLOBAL_VtxArrayX[LastGlobalMCEventNr],GLOBAL_VtxArrayY[LastGlobalMCEventNr],GLOBAL_VtxArrayZ[LastGlobalMCEventNr]);
        }
        //
        else if (GLOBAL_InBT_MC<0 && cmd_GBMC==0) {
            if( IsFirstLoopCount==kTRUE) cout << "Option: GLOBAL_InBT_MC<0 && cmd_GBMC==0"<<endl;
            vtx->SetXYZ(InBT->X()-650*InBT->TX(),InBT->Y()-650*InBT->TY(),InBT->Z()-650);
        }
        else if (GLOBAL_InBT_MC<0 && cmd_GBMC>0) {
            if( IsFirstLoopCount==kTRUE)  cout << "Option: GLOBAL_InBT_MC<0 && cmd_GBMC>0"<<endl;
            vtx->SetXYZ(GLOBAL_VtxArrayX[cmd_GBMC],GLOBAL_VtxArrayY[cmd_GBMC],GLOBAL_VtxArrayZ[cmd_GBMC]);
        }
        else if (GLOBAL_InBT_MC>0 && GLOBAL_IsBrickTreePGunInfo==kFALSE) {
            if( IsFirstLoopCount==kTRUE) cout << "Option: GLOBAL_InBT_MC>0 && GLOBAL_IsBrickTreePGunInfo==kFALSE"<<endl;
            vtx->SetXYZ(InBT->X()-650*InBT->TX(),InBT->Y()-650*InBT->TY(),InBT->Z()-650);
        }
        else {
            if( IsFirstLoopCount==kTRUE) cout << "Option: else"<<endl;
            vtx->SetXYZ(GLOBAL_VtxArrayX[GLOBAL_InBT_MC],GLOBAL_VtxArrayY[GLOBAL_InBT_MC],GLOBAL_VtxArrayZ[GLOBAL_InBT_MC]);
        }
        vtx->SetMC(GLOBAL_InBT_MC);
 
        if (gEDBDEBUGLEVEL>2) {
            cout << "The vtx info for this MC event: X:Y:Z:MC:  " << vtx->X()  << " " << vtx->Y() << " " << vtx->Z() << " " << GLOBAL_InBT_MC << endl;
            cout << "The vtx info for this MC event: IP(INBT,vtx):  " << CalcIP(InBT,vtx)<< endl;
        }
        //-----------------------------------
 
 
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
 
        // IN THIS ALGORITHM WE DO NOT YET AUTOMATICALLY ADD THE FIRST BT
        // SINCE WE NEED AN ADDIITONAL VERTEX CUT OF THIS FIRST BT TO CHECK!
        // // Add InBT to GLOBAL_ShowerSegArray
        // GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check InitiatorBT
        // 2) compatible with a segment forming a e+e- pair:
        // 2) (Loop over all plates of local_gAli, since this is already
        // 2) extracted with the right numbers of plates...)
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        Int_t btloop_cnt_N=0;
 
 
 
 
        Int_t npat=local_gAli->Npatterns();
        Int_t pat_one_bt_cnt_max,pat_two_bt_cnt_max=0;
        EdbPattern* pat_one=0;
        EdbPattern* pat_two=0;
        EdbSegP* Segment=0;
        EdbSegP* Segment2=0;
        Float_t distZ,IP_Pair_To_InBT,IP_Pair_To_InBT_SegSum;
        Float_t IP_Pair_To_InBT_Seg2;
 
 
        Segment = InBT;
        IP_Pair_To_InBT=CalcIP(Segment, vtx);
 
 
 
 
 
 
 
        // Loop over pattern for the first BT of the pairs:
        // Start first with the pattern with the lowest Z position.
        pat_one=local_gAli->GetPatternZLowestHighest(1);
        Float_t pat_one_Z=pat_one->Z();
        pat_one_bt_cnt_max=pat_one->GetN();
 
        for (Int_t pat_one_cnt=0; pat_one_cnt<npat; ++pat_one_cnt) {
 
 
            if (pat_one_cnt>0) {
                pat_one=(EdbPattern*)local_gAli->NextPattern(pat_one_Z,1);
                pat_one_Z=pat_one->Z();
                pat_one_bt_cnt_max=pat_one->GetN();
            }
 
            // Check if pattern Z() equals the InBZ->Z(), since we wanna have the
            // pattern one the pattern to contain the InBT:
            distZ=pat_one->Z()-InBT->Z();
            if (TMath::Abs(distZ)>10) continue;
            //cout << "distZ (pat_one->Z()-InBT->Z())= " << distZ << endl;
 
            // Check if InBT fulfills criteria for IP to vertex:
            if (IP_Pair_To_InBT>CUT_PARAMETER[0]) continue;
            // Check if InBT fulfills criteria for z-diff to vertex:
            if ((InBT->Z()-vtx->Z())>CUT_PARAMETER[3]) continue;
 
            // Now here we can add InBT since it passed also the vertex cut.
            // Therefore, the Reconstructed Shower has always InBT as first BT stored.
            if (GLOBAL_ShowerSegArray->GetEntries()==0) {
                GLOBAL_ShowerSegArray->Add(InBT);
                if (gEDBDEBUGLEVEL>2) {
                    cout << "I have added the first InBT  " << InBT << "  to GLOBAL_ShowerSegArray." << endl;
                    InBT->PrintNice();
                }
            }
 
            // Check if pattern dist Z to Vtx  is ok:
            distZ=pat_one->Z()-vtx->Z();
            // Z distance has to be greater zero, cause the InBT
            // and other pair BTs shall come downstream the vertex:
            if (distZ<0) continue;
            //cout << "distZ (pat_one->Z()-vtx->Z();) = " << distZ << endl;
 
            if (gEDBDEBUGLEVEL>2) cout << "Searching patterns: pat_one_cnt=" << pat_one_cnt << "  pat_one->Z() = " << pat_one->Z() << " pat_one_bt_cnt_max= "<< pat_one_bt_cnt_max <<endl;
 
 
            // Loop over pattern for the second BT of the pairs:
            //
            //cout << "// Loop over pattern for the second BT of the pairs: "<< endl;
 
            pat_two=local_gAli->GetPatternZLowestHighest(1);
            Float_t pat_two_Z=pat_two->Z();
            pat_two_bt_cnt_max=pat_two->GetN();
 
            for (Int_t pat_two_cnt=0; pat_two_cnt<npat; ++pat_two_cnt) {
 
                if (pat_two_cnt>0) {
                    pat_two=(EdbPattern*)local_gAli->NextPattern(pat_two_Z,1);
                    pat_two_Z=pat_two->Z();
                    pat_two_bt_cnt_max=pat_two->GetN();
                }
 
                // PID diff of two plates may be maximum [0..PidDIFFN]
                if (TMath::Abs(pat_one_cnt-pat_two_cnt)>CUT_PARAMETER[5]) continue;
 
                // pattern two should come downstream pattern one:
                if (pat_two->Z()<pat_one->Z()) continue;
 
 
                if (gEDBDEBUGLEVEL>2) cout << " Searching patterns: pat_two_cnt=" << pat_two_cnt << "  pat_two->Z() = " << pat_two->Z() << " pat_two_bt_cnt_max= "<< pat_two_bt_cnt_max <<endl;
 
 
                for (Int_t pat_one_bt_cnt=0; pat_one_bt_cnt<pat_one_bt_cnt_max; ++pat_one_bt_cnt) {
 
                    for (Int_t pat_two_bt_cnt=0; pat_two_bt_cnt<pat_two_bt_cnt_max; ++pat_two_bt_cnt) {
                        Segment2 = (EdbSegP*)pat_two->GetSegment(pat_two_bt_cnt);
 
                        // Ceck if segments are not (by chance) the same:
                        if (Segment2==Segment) continue;
                        if (Segment2->ID()==Segment->ID()&&Segment2->PID()==Segment->PID()) continue;
                        if (IsSameSegment(Segment2,Segment)) continue;
 
 
 
 
                        // Now apply cut conditions: GS  GAMMA SEARCH Alg  --------------------
 
                        // Check if IP of both to vtx (BT) is ok:
                        IP_Pair_To_InBT_Seg2  =CalcIP(Segment2, vtx);
                        if (IP_Pair_To_InBT_Seg2>CUT_PARAMETER[0]) continue;
 
                        // if InBT is flagged as MC InBT, take care that only BG or same MC basetracks are taken:
                        if (InBT->MCEvt()>0) if (Segment->MCEvt()>0&&Segment2->MCEvt()>0) if (Segment->MCEvt()!=Segment2->MCEvt()) continue;
                        if (InBT->MCEvt()>0) if (Segment->MCEvt()>0&&Segment2->MCEvt()>0) if (Segment->MCEvt()!=InBT->MCEvt()) continue;
                        if (InBT->MCEvt()>0) if (Segment->MCEvt()>0&&Segment2->MCEvt()>0) if (Segment2->MCEvt()!=InBT->MCEvt()) continue;
 
                        // In case of two MC events, check for e+ e- pairs
                        // Do this ONLY IF parameter eParaValue[6] is set to choose different Flag() pairs:
                        if (InBT->MCEvt()>0 && CUT_PARAMETER[6]==1) {
                            if (Segment->MCEvt()>0&&Segment2->MCEvt()>0) {
                                if ((Segment2->Flag()+Segment->Flag())!=0) continue;
                            }
                        }
 
                        // a) Check dR between tracks:
                        if (GetdeltaRWithPropagation(Segment,Segment2)>CUT_PARAMETER[2]) continue;
                        // b) Check dT between tracks:
                        if (GetdeltaThetaSingleAngles(Segment,Segment2)>CUT_PARAMETER[4]) continue;
                        // c) Check dMinDist between tracks:
                        if (GetMinimumDist(Segment,Segment2)>CUT_PARAMETER[1]) continue;
 
                        // f) Check if this is not a possible fake doublet which is
                        //    sometimes caused by view overlap in the scanning:
                        //    in the EdbPVRQuality class this will be done at start for the whole
                        //    PVR object so this will be later on obsolete.
                        //
                        // end of    cut conditions: GS  GAMMA SEARCH Alg  --------------------
                        //
 
 
                        if (gEDBDEBUGLEVEL>3) {
                            cout << "EdbShowAlg_GS::FindPairs   Pair (PID:" << Segment->PID() << ",ID:" << Segment->ID()<< ";"<< Segment2->PID() << "," << Segment2->ID() << ") has passed all cuts w.r.t to InBT:" << endl;
                            cout << "EdbShowAlg_GS::FindPairs   GetdeltaRWithPropagation(Segment,Segment2)  = " << GetdeltaRWithPropagation(Segment,Segment2) << endl;
                            cout << "EdbShowAlg_GS::FindPairs   GetdeltaThetaSingleAngles(Segment,Segment2)  = " << GetdeltaThetaSingleAngles(Segment,Segment2) << endl;
                            cout << "EdbShowAlg_GS::FindPairs   GetMinimumDist(Segment,Segment2)  = " << GetMinimumDist(Segment,Segment2) << endl;
                            cout << "EdbShowAlg_GS::FindPairs   CalcIP(BetterSegment,InBT)  = " << IP_Pair_To_InBT << endl;
                        }
 
                        if (gEDBDEBUGLEVEL>3)  cout <<"------------"<< endl;
 
                        // And Add Segment2 to to shower array:
//                         cout << "// Add Segment2 to to shower array (AddBTToArrayWithCeck):" << endl;
                        Bool_t isContained = AddBTToArrayWithCeck(Segment2, GLOBAL_ShowerSegArray);
                        //PrintShowerObjectArray(GLOBAL_ShowerSegArray);
//                                              cout << " isContained == " << isContained << endl;
                        if (isContained==kTRUE) continue;
 
                    } //for (Int_t pat_two_bt_cnt=0; ...
 
                } //for (Int_t pat_one_bt_cnt=0; ...
 
            } // for (Int_t pat_two_cnt=0; ...
 
 
            // Now here do the usual rest for BG density calculation:
            //...
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(pat_one_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
        } //for (Int_t pat_one_cnt=0; ...
 
 
 
        if (gEDBDEBUGLEVEL>2) cout << " GLOBAL_ShowerSegArray->GetEntries() " << GLOBAL_ShowerSegArray->GetEntries() << endl;
 
 
        if (GLOBAL_ShowerSegArray->GetEntries()>1) {
 
            Segment=(EdbSegP*)GLOBAL_ShowerSegArray->At(0);
            Segment2=(EdbSegP*)GLOBAL_ShowerSegArray->At(1);
 
 
 
            if (gEDBDEBUGLEVEL>2) {
                cout << "ONLY FOR THE ANN TRAINING FOR GS ALGO: "  << endl;
                cout << "DO THIS ONLY IF YOU HAVE PAIRS !!!: "  << endl;
                cout << "YES WE HAVE A PAIR Print all segs in the array: "  << endl;
                for (int l=0; l<GLOBAL_ShowerSegArray->GetEntries(); ++l) {
                    EdbSegP* s=(EdbSegP*)GLOBAL_ShowerSegArray->At(l);
                    s->PrintNice();
                }
//                  Segment->PrintNice();
//                  Segment2->PrintNice();
                cout << "Print again the InBT for crosscheck: InBT= " << endl;
                InBT->PrintNice();
                cout << "Address of Segment   = " << Segment << endl;
                cout << "Address of Segment2  = " << Segment2 << endl;
            }
 
 
 
            // Implicitly, we assume that InBT= Seg->At(0), which I checked is
            // correct. Also in the code it is done this way that InBT is added
            // as first BT.
            //Segment->PrintNice();
            //Segment2->PrintNice();
            //InBT->PrintNice();
 
            IP_Pair_To_InBT_Seg2=CalcIP(Segment2,vtx);
            IP_Pair_To_InBT=CalcIP(Segment,vtx);
 
            // Check if both basetracks have a vertex which is upstream
            // of both tracks (only then the two BT are really pointing).
            TObjArray *segments = new TObjArray(2);
            segments->Clear();
            segments->Add(Segment);
            segments->Add(Segment2);
            EdbVertex* vetex = new EdbVertex();
            vetex = CalcVertex(segments);
            cout << "Calculated helper _vetex_ out of the first two segments. " << endl;
            cout <<"vetex ->X,Y,Z:  " << vetex ->X() << " " << vetex ->Y() << " " << vetex ->Z()<< endl;
            if (vetex ->Z()> TMath::Min(Segment->Z(),Segment2->Z()) ) cout << "The interims vertex to which the two segments points lies downstream, or in between the to segmnets, i.e. the do NOT point to an originating vertex. continue now...." << endl;
            cout << "Check:  TMath::Min(Segment->Z(),Segment2->Z())  " <<  TMath::Min(Segment->Z(),Segment2->Z())  << endl;
            cout <<"Segment->Z(): " << Segment->Z() << "  Segment2->Z() " << Segment2->Z() << endl;
            cout << "Address of Segment   = " << Segment << endl;
            cout << "Address of Segment2  = " << Segment2 << endl;
            if (vetex ->Z()> TMath::Min(Segment->Z(),Segment2->Z()) ) {
                cout << " Hmm, do nothing..." << endl;
            }
            else {
 
                Float_t IP_Seg1ToVtxSeg1Seg2=0;
                Float_t IP_Seg2ToVtxSeg1Seg2=0;
                IP_Seg1ToVtxSeg1Seg2 = CalcIP(Segment ,vetex);
                IP_Seg2ToVtxSeg1Seg2 = CalcIP(Segment2,vetex);
 
                Int_t eRecoMode=2;
                cout << "WARNING   eRecoMode konstant set to =2   TODO ....   change on prompt!!" << endl;
                Float_t eValueGSNN_var00;
                Float_t IP_InBT_To_Vtx=IP_Pair_To_InBT;
                if (eRecoMode==0) eValueGSNN_var00=IP_InBT_To_Vtx;
                if (eRecoMode==1) eValueGSNN_var00=IP_InBT_To_Vtx;
                if (eRecoMode==2) {
                    eValueGSNN_var00=TMath::Min(IP_Seg1ToVtxSeg1Seg2,IP_Seg2ToVtxSeg1Seg2);
                }
 
                h_GSNN_var00->Fill(eValueGSNN_var00);
                h_GSNN_var01->Fill(GetMinimumDist(Segment,Segment2));
                h_GSNN_var02->Fill(GetdeltaRWithPropagation(Segment,Segment2));
                h_GSNN_var03->Fill(InBT->Z()-vtx->Z());
                h_GSNN_var04->Fill(GetdeltaThetaSingleAngles(Segment,Segment2));
                h_GSNN_var05->Fill(TMath::Abs(Segment->PID()-Segment2->PID()));
                h_GSNN_var06->Fill(Segment2->Flag()+Segment->Flag());
 
                // Purity 1:    Input =  1.0;
                // Purity 0.5:  Input =  0.5;
                // Purity else: Input =  0.0;
                if (Segment2->Flag()+Segment->Flag()==0&&TMath::Abs(Segment2->Flag())==11&&Segment->MCEvt()>0) {
                    value_GSNN_varInput=1;
                }
                else if (Segment2->Flag()+Segment->Flag()!=0&&TMath::Abs(Segment2->Flag())==11&&Segment->MCEvt()>0) {
                    value_GSNN_varInput=0.5;
                }
                else {
                    value_GSNN_varInput=0;
                }
                value_GSNN_var00=eValueGSNN_var00;
                value_GSNN_var01=GetMinimumDist(Segment,Segment2);
                value_GSNN_var02=GetdeltaRWithPropagation(Segment,Segment2);
                value_GSNN_var03=InBT->Z()-vtx->Z();
                value_GSNN_var04=GetdeltaThetaSingleAngles(Segment,Segment2);
                value_GSNN_var05=TMath::Abs(Segment->PID()-Segment2->PID());
                value_GSNN_var06=Segment2->Flag()+Segment->Flag();
 
                t_GSNN->Fill();
 
                cout << "I have filled the GSNN Tree now. End of this bracket." << endl;
            }
        }
 
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
        Int_t s_NBT=0;
        Int_t s_NBTMC=0;
        Int_t s_NBTallMC=0;
        Int_t s_NBTeMC=0;
        Double_t  s_eff=0;
        Double_t s_purall=0;
        Double_t s_pure=0;
        CalcEffPurOfShower(GLOBAL_ShowerSegArray, s_NBT, s_NBTMC, s_NBTallMC, s_NBTeMC, s_purall, s_pure);
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
//         cout << "// 4) Calculate pur/eff/NBT numbers...done." << endl;
 
 
//              XXXDEBUG
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        if (gEDBDEBUGLEVEL>2)   cout << "// 5) Fill Tree:" << endl;
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            //cout << "// 6a) Transfer ShowerArray to treebranchTreeEntry:" << endl;
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>2) cout << "--- --- after clear:  GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
 
 
 
        IsFirstLoopCount=kFALSE;
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
 
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_GS() done.");
    return;
}

ReconstructShowers_NN()

void ReconstructShowers_NN

(

)

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_NN() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of NN Algorithm
    //-----------------------------------------------------------------
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
 
    // Define NN_ALG charactereistic variables:
    Float_t dT_InBT_To_TestBT=0;
    Float_t dR_InBT_To_TestBT=0;
    Float_t dR_TestBT_To_InBT=0;
    Float_t zDist_TestBT_To_InBT=0;
    Float_t SpatialDist_TestBT_To_InBT=0;
    Float_t zDiff_TestBT_To_InBT=0;
    Float_t dT_NextBT_To_TestBT=0;
    Float_t dR_NextBT_To_TestBT=0;
    Float_t mean_dT_2before=0;
    Float_t mean_dR_2before=0;
    Float_t  mean_dT_before=0;
    Float_t mean_dR_before=0;
    Float_t  mean_dT_same=0;
    Float_t mean_dR_same=0;
    Float_t  mean_dT_after=0;
    Float_t mean_dR_after=0;
    Float_t  mean_dT_2after=0;
    Float_t  mean_dR_2after=0;
 
    Float_t min_dT_2before=0;
    Float_t min_dR_2before=0;
    Float_t  min_dT_before=0;
    Float_t min_dR_before=0;
    Float_t  min_dT_same=0;
    Float_t min_dR_same=0;
    Float_t  min_dT_after=0;
    Float_t min_dR_after=0;
    Float_t  min_dT_2after=0;
    Float_t  min_dR_2after=0;
    Int_t nseg_1before=0;
    Int_t nseg_2before=0;
    Int_t nseg_3before=0;
    Int_t nseg_1after=0;
    Int_t nseg_2after=0;
    Int_t nseg_3after=0;
    Int_t nseg_same=0;
    Int_t type;
 
    // Variables and things important for neural Network:
    TTree *simu = new TTree("MonteCarlo", "Filtered Monte Carlo Events");
    simu->Branch("dT_InBT_To_TestBT", &dT_InBT_To_TestBT, "dT_InBT_To_TestBT/F");
    simu->Branch("dR_InBT_To_TestBT",  &dR_InBT_To_TestBT,  "dR_InBT_To_TestBT/F");
    simu->Branch("dR_TestBT_To_InBT",    &dR_TestBT_To_InBT,    "dR_TestBT_To_InBT/F");
    simu->Branch("zDiff_TestBT_To_InBT",  &zDiff_TestBT_To_InBT,  "zDiff_TestBT_To_InBT/F");
    simu->Branch("SpatialDist_TestBT_To_InBT",  &SpatialDist_TestBT_To_InBT,  "SpatialDist_TestBT_To_InBT/F");
    simu->Branch("nseg_1before",  &nseg_1before,  "nseg_1before/I");
    simu->Branch("nseg_2before",  &nseg_2before,  "nseg_2before/I");
    simu->Branch("nseg_same",  &nseg_same,  "nseg_same/I");
    simu->Branch("nseg_1after",  &nseg_1after,  "nseg_1after/I");
    simu->Branch("nseg_2after",  &nseg_2after,  "nseg_2after/I");
    //---------
    simu->Branch("mean_dT_2before",  &mean_dT_2before,  "mean_dT_2before/F");
    simu->Branch("mean_dT_before",  &mean_dT_before,  "mean_dT_before/F");
    simu->Branch("mean_dT_same",  &mean_dT_same,  "mean_dT_same/F");
    simu->Branch("mean_dT_after",  &mean_dT_after,  "mean_dT_after/F");
    simu->Branch("mean_dT_2after",  &mean_dT_2after,  "mean_dT_2after/F");
    //---------
    simu->Branch("mean_dR_2before",  &mean_dR_2before,  "mean_dR_2before/F");
    simu->Branch("mean_dR_before",  &mean_dR_before,  "mean_dR_before/F");
    simu->Branch("mean_dR_same",  &mean_dR_same,  "mean_dR_same/F");
    simu->Branch("mean_dR_after",  &mean_dR_after,  "mean_dR_after/F");
    simu->Branch("mean_dR_2after",  &mean_dR_2after,  "mean_dR_2after/F");
    //---------
    simu->Branch("min_dT_2before",  &min_dT_2before,  "min_dT_2before/F");
    simu->Branch("min_dT_before",  &min_dT_before,  "min_dT_before/F");
    simu->Branch("min_dT_same",  &min_dT_same,  "min_dT_same/F");
    simu->Branch("min_dT_after",  &min_dT_after,  "min_dT_after/F");
    simu->Branch("min_dT_2after",  &min_dT_2after,  "min_dT_2after/F");
    //---------
    simu->Branch("min_dR_2before",  &min_dR_2before,  "min_dR_2before/F");
    simu->Branch("min_dR_before",  &min_dR_before,  "min_dR_before/F");
    simu->Branch("min_dR_same",  &min_dR_same,  "min_dR_same/F");
    simu->Branch("min_dR_after",  &min_dR_after,  "min_dR_after/F");
    simu->Branch("min_dR_2after",  &min_dR_2after,  "min_dR_2after/F");
 
    simu->Branch("type",   &type,   "type/I");
    Double_t params[8];
    //------------------------------
    TTree *simu_SG = (TTree *)simu->Clone();//new TTree("TreeSignalBT", "TreeSignalBT");
    simu_SG->SetName("TreeSignalBT");
    simu_SG->SetTitle("TreeSignalBT");
    TTree *simu_BG = (TTree *)simu->Clone();// TTree *simu_BG = new TTree("TreeBackgroundBT", "TreeBackgroundBT");
    simu_BG->SetName("TreeBackgroundBT");
    simu_BG->SetTitle("TreeBackgroundBT");
    //------------------------------
 
 
    // Create Histograms:
    // Only in Case of Training:
    if (var_NN_DoTrain==kTRUE) {
        Create_NN_Alg_Histograms();
        cout << "histos created"<<endl;
    }
 
    //  Get the right TMLP for the right Parameterset:
    Get_NN_ALG_MLP(simu, GLOBAL_PARASETNR);
    Load_NN_ALG_MLP_weights(TMlpANN,GLOBAL_PARASETNR);
    cout << TMlpANN->GetStructure() << endl;
    //  return;
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
 
        //-----------------------------------
        // 1a) Reset characteristic variables:
        //-----------------------------------
        dT_InBT_To_TestBT=0;
        dR_InBT_To_TestBT=0;
        dR_TestBT_To_InBT=0;
        zDiff_TestBT_To_InBT=0;
        mean_dT_2before=0;
        mean_dR_2before=0;
        mean_dT_before=0;
        mean_dR_before=0;
        mean_dT_same=0;
        mean_dR_same=0;
        mean_dT_after=0;
        mean_dR_after=0;
        mean_dT_2after=0;
        mean_dR_2after=0;
        nseg_1before=0;
        nseg_2before=0;
        nseg_1after=0;
        nseg_2after=0;
        nseg_same=0;
        min_dT_2before=0;
        min_dR_2before=0;
        min_dT_before=0;
        min_dR_before=0;
        min_dT_same=0;
        min_dR_same=0;
        min_dT_after=0;
        min_dR_after=0;
        min_dT_2after=0;
        min_dR_2after=0;
 
        int ann_inputneurons=CUT_PARAMETER[1];
 
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
            // Needed to have StepX,Y,TX,TY bins set for the FindCompliments Function.
            //EdbPattern* ActualPattern   =   (EdbPattern*)local_gAli->GetPattern(patterloop_cnt);
            //ActualPattern               ->  FillCell(20,20,0.01,0.01);
 
            for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
 
                // Now    calculate NN Histogram Inputvariables:  --------------------
                // 1) zDiff_TestBT_To_InBT and SpatialDist_TestBT_To_InBT
                zDiff_TestBT_To_InBT=seg->Z()-InBT->Z();
                SpatialDist_TestBT_To_InBT=GetSpatialDist(seg,InBT);
                // 2) dT_InBT_To_TestBT
                dT_InBT_To_TestBT=GetdeltaThetaSingleAngles(seg,InBT);
                // 3) dR_InBT_To_TestBT (propagation order matters)
                //    In calculation it makes a difference if InBT is extrapolated to Z-pos of seg or vice versa.
                dR_InBT_To_TestBT=GetdeltaRWithPropagation(InBT, seg);
                dR_TestBT_To_InBT=GetdeltaRWithPropagation(seg,InBT);
 
 
                // 4) nseg_1before,nseg_2before,nseg_1after,nseg_2after:
                if (ann_inputneurons==10) {
                    nseg_2before = GetNSegBeforeAndAfter(local_gAli,patterloop_cnt,seg,2,-1);
                    nseg_1before = GetNSegBeforeAndAfter(local_gAli,patterloop_cnt,seg,1,-1);
                    nseg_same    = GetNSegBeforeAndAfter(local_gAli,patterloop_cnt,seg,0, 1);
                    nseg_1after  = GetNSegBeforeAndAfter(local_gAli,patterloop_cnt,seg,1, 1);
                    nseg_2after  = GetNSegBeforeAndAfter(local_gAli,patterloop_cnt,seg,2, 1);
                }
 
                // 5) mean_dT,dR nseg_1before,nseg_2before,nseg_1after,nseg_2after: mean of all dTheta and dR compliment segments:
                if (ann_inputneurons==20) {
                    GetMeansBeforeAndAfter(mean_dT_2before,mean_dR_2before,local_gAli,patterloop_cnt,seg,2,-1);
                    GetMeansBeforeAndAfter(mean_dT_before,mean_dR_before,local_gAli,patterloop_cnt,seg,1,-1);
                    GetMeansBeforeAndAfter(mean_dT_same,mean_dR_same,local_gAli,patterloop_cnt,seg,0, 1);
                    GetMeansBeforeAndAfter(mean_dT_after,mean_dR_after,local_gAli,patterloop_cnt,seg,1, 1);
                    GetMeansBeforeAndAfter(mean_dT_2after,mean_dR_2after,local_gAli,patterloop_cnt,seg,2, 1);
                }
 
                // 6) nseg_1before,nseg_2before,nseg_1after,nseg_2after: mean of all dTheta and dR compliment segments:
                if (ann_inputneurons==30) {
                    GetMinsBeforeAndAfter(min_dT_2before,min_dR_2before,local_gAli,patterloop_cnt,seg,2,-1);
                    GetMinsBeforeAndAfter(min_dT_before,min_dR_before,local_gAli,patterloop_cnt,seg,1,-1);
                    GetMinsBeforeAndAfter(min_dT_same,min_dR_same,local_gAli,patterloop_cnt,seg,0, 1);
                    GetMinsBeforeAndAfter(min_dT_after,min_dR_after,local_gAli,patterloop_cnt,seg,1, 1);
                    GetMinsBeforeAndAfter(min_dT_2after,min_dR_2after,local_gAli,patterloop_cnt,seg,2, 1);
                }
                // end of calculate NN Histogram Inputvariables:  --------------------
 
 
 
                // Now    fill NN SG/BG Trees with the Inputvariables:  --------------------
                // Only in Case of Training:
                if (var_NN_DoTrain==kTRUE) {
                    if (seg->MCEvt()>0) {
                        var_NN__SG__SpatialDist_TestBT_To_InBT->Fill(SpatialDist_TestBT_To_InBT);
                        var_NN__SG__zDiff_TestBT_To_InBT->Fill(zDiff_TestBT_To_InBT);
                        var_NN__SG__dT_InBT_To_TestBT->Fill(dT_InBT_To_TestBT);
                        var_NN__SG__dR_TestBT_To_InBT->Fill(dR_InBT_To_TestBT);
                        var_NN__SG__dR_InBT_To_TestBT->Fill(dR_TestBT_To_InBT);
                        var_NN__SG__nseg_TestBT_To2BeforePlate->Fill(nseg_2before);
                        var_NN__SG__nseg_TestBT_ToBeforePlate->Fill(nseg_1before);
                        var_NN__SG__nseg_TestBT_ToSamePlate->Fill(nseg_same);
                        var_NN__SG__nseg_TestBT_ToAfterPlate->Fill(nseg_1after);
                        var_NN__SG__nseg_TestBT_To2AfterPlate->Fill(nseg_2after);
                        //---------------
                        if (mean_dT_2before!=-1) var_NN__SG__mean_dT_TestBT_To2BeforePlate->Fill(mean_dT_2before);
                        if (mean_dR_2before!=-1) var_NN__SG__mean_dR_TestBT_To2BeforePlate->Fill(mean_dR_2before);
                        if (mean_dT_before!=-1) var_NN__SG__mean_dT_TestBT_ToBeforePlate->Fill(mean_dT_before);
                        if (mean_dR_before!=-1) var_NN__SG__mean_dR_TestBT_ToBeforePlate->Fill(mean_dR_before);
                        if (mean_dT_same!=-1) var_NN__SG__mean_dT_TestBT_ToSamePlate->Fill(mean_dT_same);
                        if (mean_dR_same!=-1) var_NN__SG__mean_dR_TestBT_ToSamePlate->Fill(mean_dR_same);
                        if (mean_dT_after!=-1) var_NN__SG__mean_dT_TestBT_ToAfterPlate->Fill(mean_dT_after);
                        if (mean_dR_after!=-1) var_NN__SG__mean_dR_TestBT_ToAfterPlate->Fill(mean_dR_after);
                        if (mean_dT_2after!=-1) var_NN__SG__mean_dT_TestBT_To2AfterPlate->Fill(mean_dT_2after);
                        if (mean_dR_2after!=-1) var_NN__SG__mean_dR_TestBT_To2AfterPlate->Fill(mean_dR_2after);
                        if (min_dT_2before!=-1) var_NN__SG__min_dT_TestBT_To2BeforePlate->Fill(min_dT_2before);
                        if (min_dR_2before!=-1) var_NN__SG__min_dR_TestBT_To2BeforePlate->Fill(min_dR_2before);
                        if (min_dT_before!=-1) var_NN__SG__min_dT_TestBT_ToBeforePlate->Fill(min_dT_before);
                        if (min_dR_before!=-1) var_NN__SG__min_dR_TestBT_ToBeforePlate->Fill(min_dR_before);
                        if (min_dT_same!=-1) var_NN__SG__min_dT_TestBT_ToSamePlate->Fill(min_dT_same);
                        if (min_dR_same!=-1) var_NN__SG__min_dR_TestBT_ToSamePlate->Fill(min_dR_same);
                        if (min_dT_after!=-1) var_NN__SG__min_dT_TestBT_ToAfterPlate->Fill(min_dT_after);
                        if (min_dR_after!=-1) var_NN__SG__min_dR_TestBT_ToAfterPlate->Fill(min_dR_after);
                        if (min_dT_2after!=-1) var_NN__SG__min_dT_TestBT_To2AfterPlate->Fill(min_dT_2after);
                        if (min_dR_2after!=-1) var_NN__SG__min_dR_TestBT_To2AfterPlate->Fill(min_dR_2after);
                        type=1;
                        simu_SG->Fill();
                        simu->Fill();
                    }
                    if (seg->MCEvt()<0) {
                        var_NN__BG__SpatialDist_TestBT_To_InBT->Fill(SpatialDist_TestBT_To_InBT);
                        var_NN__BG__zDiff_TestBT_To_InBT->Fill(zDiff_TestBT_To_InBT);
                        var_NN__BG__dT_InBT_To_TestBT->Fill(dT_InBT_To_TestBT);
                        var_NN__BG__dR_TestBT_To_InBT->Fill(dR_TestBT_To_InBT);
                        var_NN__BG__dR_InBT_To_TestBT->Fill(dR_InBT_To_TestBT);
                        var_NN__BG__nseg_TestBT_To2BeforePlate->Fill(nseg_2before);
                        var_NN__BG__nseg_TestBT_ToBeforePlate->Fill(nseg_1before);
                        var_NN__BG__nseg_TestBT_ToSamePlate->Fill(nseg_same);
                        var_NN__BG__nseg_TestBT_ToAfterPlate->Fill(nseg_1after);
                        var_NN__BG__nseg_TestBT_To2AfterPlate->Fill(nseg_2after);
                        //---------------
                        if (mean_dT_2before!=-1) var_NN__BG__mean_dT_TestBT_To2BeforePlate->Fill(mean_dT_2before);
                        if (mean_dR_2before!=-1) var_NN__BG__mean_dR_TestBT_To2BeforePlate->Fill(mean_dR_2before);
                        if (mean_dT_before!=-1) var_NN__BG__mean_dT_TestBT_ToBeforePlate->Fill(mean_dT_before);
                        if (mean_dR_before!=-1) var_NN__BG__mean_dR_TestBT_ToBeforePlate->Fill(mean_dR_before);
                        if (mean_dT_same!=-1) var_NN__BG__mean_dT_TestBT_ToSamePlate->Fill(mean_dT_same);
                        if (mean_dR_same!=-1) var_NN__BG__mean_dR_TestBT_ToSamePlate->Fill(mean_dR_same);
                        if (mean_dT_after!=-1) var_NN__BG__mean_dT_TestBT_ToAfterPlate->Fill(mean_dT_after);
                        if (mean_dR_after!=-1) var_NN__BG__mean_dR_TestBT_ToAfterPlate->Fill(mean_dR_after);
                        if (mean_dT_2after!=-1) var_NN__BG__mean_dT_TestBT_To2AfterPlate->Fill(mean_dT_2after);
                        if (mean_dR_2after!=-1) var_NN__BG__mean_dR_TestBT_To2AfterPlate->Fill(mean_dR_2after);
                        //---------------
                        if (min_dT_2before!=-1) var_NN__BG__min_dT_TestBT_To2BeforePlate->Fill(min_dT_2before);
                        if (min_dR_2before!=-1) var_NN__BG__min_dR_TestBT_To2BeforePlate->Fill(min_dR_2before);
                        if (min_dT_before!=-1) var_NN__BG__min_dT_TestBT_ToBeforePlate->Fill(min_dT_before);
                        if (min_dR_before!=-1) var_NN__BG__min_dR_TestBT_ToBeforePlate->Fill(min_dR_before);
                        if (min_dT_same!=-1) var_NN__BG__min_dT_TestBT_ToSamePlate->Fill(min_dT_same);
                        if (min_dR_same!=-1) var_NN__BG__min_dR_TestBT_ToSamePlate->Fill(min_dR_same);
                        if (min_dT_after!=-1) var_NN__BG__min_dT_TestBT_ToAfterPlate->Fill(min_dT_after);
                        if (min_dR_after!=-1) var_NN__BG__min_dR_TestBT_ToAfterPlate->Fill(min_dR_after);
                        if (min_dT_2after!=-1) var_NN__BG__min_dT_TestBT_To2AfterPlate->Fill(min_dT_2after);
                        if (min_dR_2after!=-1) var_NN__BG__min_dR_TestBT_To2AfterPlate->Fill(min_dR_2after);
                        type=0;
                        simu_BG->Fill();
                        simu->Fill();
                    }
                    if (seg->MCEvt()<0 || seg->MCEvt()>0) {
                        //simu->Show(simu->GetEntries()-1); // do nothing yet...
                    }
 
                } // if Train=TRUE
                // end of   fill NN SG/BG Trees with the Inputvariables:  --------------------
 
 
                Double_t params[30];
                //              Double_t params[5];
                params[0]=dT_InBT_To_TestBT;
                params[1]=dR_InBT_To_TestBT;
                params[2]=dR_TestBT_To_InBT;
                params[3]=zDiff_TestBT_To_InBT;
                params[4]=SpatialDist_TestBT_To_InBT;
                // /*
                //              Double_t params[15];
                params[5]=nseg_2before;
                params[6]=nseg_1before;
                params[7]=nseg_same;
                params[8]=nseg_1after;
                params[9]=nseg_2after;
 
                params[10]=mean_dT_2before;
                params[11]=mean_dT_before;
                params[12]=mean_dT_same;
                params[13]=mean_dT_after;
                params[14]=mean_dT_2after;
 
                params[15]=mean_dR_2before;
                params[16]=mean_dR_before;
                params[17]=mean_dR_same;
                params[18]=mean_dR_after;
                params[19]=mean_dR_2after;
 
                params[20]=min_dT_2before;
                params[21]=min_dT_before;
                params[22]=min_dT_same;
                params[23]=min_dT_after;
                params[24]=min_dT_2after;
 
                params[25]=min_dR_2before;
                params[26]=min_dR_before;
                params[27]=min_dR_same;
                params[28]=min_dR_after;
                params[29]=min_dR_2after;
 
                //---------
                //              */
                Double_t value=0;
 
                //for (int hj=0; hj<5; hj++) cout << "  " << params[hj];
                //cout << endl;
                value=TMlpANN->Evaluate(0, params);
                //if (gEDBDEBUGLEVEL>0) { for (int hj=0; hj<10; hj++) cout << "  " << params[hj];cout << "  , Vlaue= " << value << endl; }
                //                  cout << "                               Evaluated value...."<< value<<endl;
 
                // Now apply cut conditions: NEURAL NETWORK Alg  --------------------
                if (value<CUT_PARAMETER[0]) continue;
                // end of    cut conditions: NEURAL NETWORK Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                if (seg->X()==InBT->X()&&seg->Y()==InBT->Y()) {
                    ;    // do nothing;
                }
                else {
                    GLOBAL_ShowerSegArray -> Add(seg);
                }
            }
 
 
 
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
        }
        // end of loop over all plates of local_gAli
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
 
 
    // Only in Case of Training:
    if (var_NN_DoTrain==kTRUE) {
        cout << " Now    write NN SG/BG Trees with the Inputvariables:  --------------------"<<endl;
 
        TFile* fil = new TFile("NN_ALG_ANN_TrainingsFile_DefaultName.root","RECREATE");
        TCanvas* canv_SG = new TCanvas("canv_SG","canv_SG",800,800);
        canv_SG->Divide(5,4);
        canv_SG->cd(1);
        var_NN__SG__SpatialDist_TestBT_To_InBT->Draw();
        var_NN__SG__SpatialDist_TestBT_To_InBT->SetLineColor(2);
        var_NN__SG__SpatialDist_TestBT_To_InBT->Scale(1.0/var_NN__SG__SpatialDist_TestBT_To_InBT->Integral());
        var_NN__BG__SpatialDist_TestBT_To_InBT->Draw("same");
        var_NN__BG__SpatialDist_TestBT_To_InBT->SetLineColor(4);
        var_NN__BG__SpatialDist_TestBT_To_InBT->Scale(1.0/var_NN__BG__SpatialDist_TestBT_To_InBT->Integral());
 
        canv_SG->cd(2);
        var_NN__SG__dT_InBT_To_TestBT->Draw();
        var_NN__SG__dT_InBT_To_TestBT->SetLineColor(2);
        var_NN__SG__dT_InBT_To_TestBT->Scale(1.0/var_NN__SG__dT_InBT_To_TestBT->Integral());
        var_NN__BG__dT_InBT_To_TestBT->Draw("same");
        var_NN__BG__dT_InBT_To_TestBT->SetLineColor(4);
        var_NN__BG__dT_InBT_To_TestBT->Scale(1.0/var_NN__BG__dT_InBT_To_TestBT->Integral());
 
        canv_SG->cd(3);
        var_NN__SG__dR_InBT_To_TestBT->Draw();
        var_NN__SG__dR_InBT_To_TestBT->Draw();
        var_NN__SG__dR_InBT_To_TestBT->SetLineColor(2);
        var_NN__SG__dR_InBT_To_TestBT->Scale(1.0/var_NN__SG__dR_InBT_To_TestBT->Integral());
        var_NN__BG__dR_InBT_To_TestBT->Draw("same");
        var_NN__BG__dR_InBT_To_TestBT->SetLineColor(4);
        var_NN__BG__dR_InBT_To_TestBT->Scale(1.0/var_NN__BG__dR_InBT_To_TestBT->Integral());
 
        canv_SG->cd(4);
        var_NN__SG__nseg_TestBT_To2BeforePlate->Draw();
        var_NN__SG__nseg_TestBT_To2BeforePlate->SetLineColor(2);
        var_NN__SG__nseg_TestBT_To2BeforePlate->Scale(1.0/var_NN__SG__nseg_TestBT_To2BeforePlate->Integral());
        var_NN__BG__nseg_TestBT_To2BeforePlate->Draw("same");
        var_NN__BG__nseg_TestBT_To2BeforePlate->SetLineColor(4);
        var_NN__BG__nseg_TestBT_To2BeforePlate->Scale(1.0/var_NN__BG__nseg_TestBT_To2BeforePlate->Integral());
 
        canv_SG->cd(5);
        var_NN__SG__nseg_TestBT_ToBeforePlate->Draw();
        var_NN__SG__nseg_TestBT_ToBeforePlate->SetLineColor(2);
        var_NN__SG__nseg_TestBT_ToBeforePlate->Scale(1.0/var_NN__SG__nseg_TestBT_ToBeforePlate->Integral());
        var_NN__BG__nseg_TestBT_ToBeforePlate->Draw("same");
        var_NN__BG__nseg_TestBT_ToBeforePlate->SetLineColor(4);
        var_NN__BG__nseg_TestBT_ToBeforePlate->Scale(1.0/var_NN__BG__nseg_TestBT_ToBeforePlate->Integral());
 
        canv_SG->cd(6);
        var_NN__SG__nseg_TestBT_ToSamePlate->Draw();
        var_NN__SG__nseg_TestBT_ToSamePlate->SetLineColor(2);
        var_NN__SG__nseg_TestBT_ToSamePlate->Scale(1.0/var_NN__SG__nseg_TestBT_ToSamePlate->Integral());
        var_NN__BG__nseg_TestBT_ToSamePlate->Draw("same");
        var_NN__BG__nseg_TestBT_ToSamePlate->SetLineColor(4);
        var_NN__BG__nseg_TestBT_ToSamePlate->Scale(1.0/var_NN__BG__nseg_TestBT_ToSamePlate->Integral());
 
        canv_SG->cd(7);
        var_NN__SG__nseg_TestBT_ToAfterPlate->Draw();
        var_NN__SG__nseg_TestBT_ToAfterPlate->SetLineColor(2);
        var_NN__SG__nseg_TestBT_ToAfterPlate->Scale(1.0/var_NN__SG__nseg_TestBT_ToAfterPlate->Integral());
        var_NN__BG__nseg_TestBT_ToAfterPlate->Draw("same");
        var_NN__BG__nseg_TestBT_ToAfterPlate->SetLineColor(4);
        var_NN__BG__nseg_TestBT_ToAfterPlate->Scale(1.0/var_NN__BG__nseg_TestBT_ToAfterPlate->Integral());
 
        canv_SG->cd(8);
        var_NN__SG__nseg_TestBT_To2AfterPlate->Draw();
        var_NN__SG__nseg_TestBT_To2AfterPlate->SetLineColor(2);
        var_NN__SG__nseg_TestBT_To2AfterPlate->Scale(1.0/var_NN__SG__nseg_TestBT_To2AfterPlate->Integral());
        var_NN__BG__nseg_TestBT_To2AfterPlate->Draw("same");
        var_NN__BG__nseg_TestBT_To2AfterPlate->SetLineColor(4);
        var_NN__BG__nseg_TestBT_To2AfterPlate->Scale(1.0/var_NN__BG__nseg_TestBT_To2AfterPlate->Integral());
 
 
        //-----------------//-----------------//-----------------
 
        canv_SG->cd(9);
        var_NN__SG__mean_dT_TestBT_To2BeforePlate->Draw();
        var_NN__SG__mean_dT_TestBT_To2BeforePlate->SetLineColor(2);
        var_NN__SG__mean_dT_TestBT_To2BeforePlate->Scale(1.0/var_NN__SG__mean_dT_TestBT_To2BeforePlate->Integral());
        var_NN__BG__mean_dT_TestBT_To2BeforePlate->Draw("same");
        var_NN__BG__mean_dT_TestBT_To2BeforePlate->SetLineColor(4);
        var_NN__BG__mean_dT_TestBT_To2BeforePlate->Scale(1.0/var_NN__BG__mean_dT_TestBT_To2BeforePlate->Integral());
 
        canv_SG->cd(10);
        var_NN__SG__mean_dR_TestBT_To2BeforePlate->Draw();
        var_NN__SG__mean_dR_TestBT_To2BeforePlate->SetLineColor(2);
        var_NN__SG__mean_dR_TestBT_To2BeforePlate->Scale(1.0/var_NN__SG__mean_dR_TestBT_To2BeforePlate->Integral());
        var_NN__BG__mean_dR_TestBT_To2BeforePlate->Draw("same");
        var_NN__BG__mean_dR_TestBT_To2BeforePlate->SetLineColor(4);
        var_NN__BG__mean_dR_TestBT_To2BeforePlate->Scale(1.0/var_NN__BG__mean_dR_TestBT_To2BeforePlate->Integral());
 
        //-----------------
 
        canv_SG->cd(11);
        var_NN__SG__mean_dT_TestBT_ToBeforePlate->Draw();
        var_NN__SG__mean_dT_TestBT_ToBeforePlate->SetLineColor(2);
        var_NN__SG__mean_dT_TestBT_ToBeforePlate->Scale(1.0/var_NN__SG__mean_dT_TestBT_ToBeforePlate->Integral());
        var_NN__BG__mean_dT_TestBT_ToBeforePlate->Draw("same");
        var_NN__BG__mean_dT_TestBT_ToBeforePlate->SetLineColor(4);
        var_NN__BG__mean_dT_TestBT_ToBeforePlate->Scale(1.0/var_NN__BG__mean_dT_TestBT_ToBeforePlate->Integral());
 
        canv_SG->cd(12);
        var_NN__SG__mean_dR_TestBT_ToBeforePlate->Draw();
        var_NN__SG__mean_dR_TestBT_ToBeforePlate->SetLineColor(2);
        var_NN__SG__mean_dR_TestBT_ToBeforePlate->Scale(1.0/var_NN__SG__mean_dR_TestBT_ToBeforePlate->Integral());
        var_NN__BG__mean_dR_TestBT_ToBeforePlate->Draw("same");
        var_NN__BG__mean_dR_TestBT_ToBeforePlate->SetLineColor(4);
        var_NN__BG__mean_dR_TestBT_ToBeforePlate->Scale(1.0/var_NN__BG__mean_dR_TestBT_ToBeforePlate->Integral());
 
        //-----------------
 
        canv_SG->cd(13);
        var_NN__SG__mean_dT_TestBT_ToSamePlate->Draw();
        var_NN__SG__mean_dT_TestBT_ToSamePlate->SetLineColor(2);
        var_NN__SG__mean_dT_TestBT_ToSamePlate->Scale(1.0/var_NN__SG__mean_dT_TestBT_ToSamePlate->Integral());
        var_NN__BG__mean_dT_TestBT_ToSamePlate->Draw("same");
        var_NN__BG__mean_dT_TestBT_ToSamePlate->SetLineColor(4);
        var_NN__BG__mean_dT_TestBT_ToSamePlate->Scale(1.0/var_NN__BG__mean_dT_TestBT_ToSamePlate->Integral());
 
        canv_SG->cd(14);
        var_NN__SG__mean_dR_TestBT_ToSamePlate->Draw();
        var_NN__SG__mean_dR_TestBT_ToSamePlate->SetLineColor(2);
        var_NN__SG__mean_dR_TestBT_ToSamePlate->Scale(1.0/var_NN__SG__mean_dR_TestBT_ToSamePlate->Integral());
        var_NN__BG__mean_dR_TestBT_ToSamePlate->Draw("same");
        var_NN__BG__mean_dR_TestBT_ToSamePlate->SetLineColor(4);
        var_NN__BG__mean_dR_TestBT_ToSamePlate->Scale(1.0/var_NN__BG__mean_dR_TestBT_ToSamePlate->Integral());
 
        //-----------------
 
        canv_SG->cd(15);
        var_NN__SG__mean_dT_TestBT_ToAfterPlate->Draw();
        var_NN__SG__mean_dT_TestBT_ToAfterPlate->SetLineColor(2);
        var_NN__SG__mean_dT_TestBT_ToAfterPlate->Scale(1.0/var_NN__SG__mean_dT_TestBT_ToAfterPlate->Integral());
        var_NN__BG__mean_dT_TestBT_ToAfterPlate->Draw("same");
        var_NN__BG__mean_dT_TestBT_ToAfterPlate->SetLineColor(4);
        var_NN__BG__mean_dT_TestBT_ToAfterPlate->Scale(1.0/var_NN__BG__mean_dT_TestBT_ToAfterPlate->Integral());
 
        canv_SG->cd(16);
        var_NN__SG__mean_dR_TestBT_ToAfterPlate->Draw();
        var_NN__SG__mean_dR_TestBT_ToAfterPlate->SetLineColor(2);
        var_NN__SG__mean_dR_TestBT_ToAfterPlate->Scale(1.0/var_NN__SG__mean_dR_TestBT_ToAfterPlate->Integral());
        var_NN__BG__mean_dR_TestBT_ToAfterPlate->Draw("same");
        var_NN__BG__mean_dR_TestBT_ToAfterPlate->SetLineColor(4);
        var_NN__BG__mean_dR_TestBT_ToAfterPlate->Scale(1.0/var_NN__BG__mean_dR_TestBT_ToAfterPlate->Integral());
 
 
        canv_SG->cd(17);
        var_NN__SG__mean_dT_TestBT_To2AfterPlate->Draw();
        var_NN__SG__mean_dT_TestBT_To2AfterPlate->SetLineColor(2);
        var_NN__SG__mean_dT_TestBT_To2AfterPlate->Scale(1.0/var_NN__SG__mean_dT_TestBT_To2AfterPlate->Integral());
        var_NN__BG__mean_dT_TestBT_To2AfterPlate->Draw("same");
        var_NN__BG__mean_dT_TestBT_To2AfterPlate->SetLineColor(4);
        var_NN__BG__mean_dT_TestBT_To2AfterPlate->Scale(1.0/var_NN__BG__mean_dT_TestBT_To2AfterPlate->Integral());
 
        canv_SG->cd(18);
        var_NN__SG__mean_dR_TestBT_To2AfterPlate->Draw();
        var_NN__SG__mean_dR_TestBT_To2AfterPlate->SetLineColor(2);
        var_NN__SG__mean_dR_TestBT_To2AfterPlate->Scale(1.0/var_NN__SG__mean_dR_TestBT_To2AfterPlate->Integral());
        var_NN__BG__mean_dR_TestBT_To2AfterPlate->Draw("same");
        var_NN__BG__mean_dR_TestBT_To2AfterPlate->SetLineColor(4);
        var_NN__BG__mean_dR_TestBT_To2AfterPlate->Scale(1.0/var_NN__BG__mean_dR_TestBT_To2AfterPlate->Integral());
 
        canv_SG->Update();
 
 
 
        //-----------------//-----------------//-----------------
        TCanvas* canv_SG_2 = new TCanvas("canv_SG_2","canv_SG_2",800,800);
        canv_SG_2->Divide(4,4);
        canv_SG_2->cd(1);
        canv_SG_2->cd(1);
        var_NN__SG__min_dT_TestBT_To2BeforePlate->Draw();
        var_NN__SG__min_dT_TestBT_To2BeforePlate->SetLineColor(2);
        var_NN__SG__min_dT_TestBT_To2BeforePlate->Scale(1.0/var_NN__SG__min_dT_TestBT_To2BeforePlate->Integral());
        var_NN__BG__min_dT_TestBT_To2BeforePlate->Draw("same");
        var_NN__BG__min_dT_TestBT_To2BeforePlate->SetLineColor(4);
        var_NN__BG__min_dT_TestBT_To2BeforePlate->Scale(1.0/var_NN__BG__min_dT_TestBT_To2BeforePlate->Integral());
 
        canv_SG_2->cd(2);
        var_NN__SG__min_dR_TestBT_To2BeforePlate->Draw();
        var_NN__SG__min_dR_TestBT_To2BeforePlate->SetLineColor(2);
        var_NN__SG__min_dR_TestBT_To2BeforePlate->Scale(1.0/var_NN__SG__min_dR_TestBT_To2BeforePlate->Integral());
        var_NN__BG__min_dR_TestBT_To2BeforePlate->Draw("same");
        var_NN__BG__min_dR_TestBT_To2BeforePlate->SetLineColor(4);
        var_NN__BG__min_dR_TestBT_To2BeforePlate->Scale(1.0/var_NN__BG__min_dR_TestBT_To2BeforePlate->Integral());
 
        //-----------------
 
        canv_SG_2->cd(3);
        var_NN__SG__min_dT_TestBT_ToBeforePlate->Draw();
        var_NN__SG__min_dT_TestBT_ToBeforePlate->SetLineColor(2);
        var_NN__SG__min_dT_TestBT_ToBeforePlate->Scale(1.0/var_NN__SG__min_dT_TestBT_ToBeforePlate->Integral());
        var_NN__BG__min_dT_TestBT_ToBeforePlate->Draw("same");
        var_NN__BG__min_dT_TestBT_ToBeforePlate->SetLineColor(4);
        var_NN__BG__min_dT_TestBT_ToBeforePlate->Scale(1.0/var_NN__BG__min_dT_TestBT_ToBeforePlate->Integral());
 
        canv_SG_2->cd(4);
        var_NN__SG__min_dR_TestBT_ToBeforePlate->Draw();
        var_NN__SG__min_dR_TestBT_ToBeforePlate->SetLineColor(2);
        var_NN__SG__min_dR_TestBT_ToBeforePlate->Scale(1.0/var_NN__SG__min_dR_TestBT_ToBeforePlate->Integral());
        var_NN__BG__min_dR_TestBT_ToBeforePlate->Draw("same");
        var_NN__BG__min_dR_TestBT_ToBeforePlate->SetLineColor(4);
        var_NN__BG__min_dR_TestBT_ToBeforePlate->Scale(1.0/var_NN__BG__min_dR_TestBT_ToBeforePlate->Integral());
 
        //-----------------
 
        canv_SG_2->cd(5);
        var_NN__SG__min_dT_TestBT_ToSamePlate->Draw();
        var_NN__SG__min_dT_TestBT_ToSamePlate->SetLineColor(2);
        var_NN__SG__min_dT_TestBT_ToSamePlate->Scale(1.0/var_NN__SG__min_dT_TestBT_ToSamePlate->Integral());
        var_NN__BG__min_dT_TestBT_ToSamePlate->Draw("same");
        var_NN__BG__min_dT_TestBT_ToSamePlate->SetLineColor(4);
        var_NN__BG__min_dT_TestBT_ToSamePlate->Scale(1.0/var_NN__BG__min_dT_TestBT_ToSamePlate->Integral());
 
        canv_SG_2->cd(6);
        var_NN__SG__min_dR_TestBT_ToSamePlate->Draw();
        var_NN__SG__min_dR_TestBT_ToSamePlate->SetLineColor(2);
        var_NN__SG__min_dR_TestBT_ToSamePlate->Scale(1.0/var_NN__SG__min_dR_TestBT_ToSamePlate->Integral());
        var_NN__BG__min_dR_TestBT_ToSamePlate->Draw("same");
        var_NN__BG__min_dR_TestBT_ToSamePlate->SetLineColor(4);
        var_NN__BG__min_dR_TestBT_ToSamePlate->Scale(1.0/var_NN__BG__min_dR_TestBT_ToSamePlate->Integral());
 
        //-----------------
 
        canv_SG_2->cd(7);
        var_NN__SG__min_dT_TestBT_ToAfterPlate->Draw();
        var_NN__SG__min_dT_TestBT_ToAfterPlate->SetLineColor(2);
        var_NN__SG__min_dT_TestBT_ToAfterPlate->Scale(1.0/var_NN__SG__min_dT_TestBT_ToAfterPlate->Integral());
        var_NN__BG__min_dT_TestBT_ToAfterPlate->Draw("same");
        var_NN__BG__min_dT_TestBT_ToAfterPlate->SetLineColor(4);
        var_NN__BG__min_dT_TestBT_ToAfterPlate->Scale(1.0/var_NN__BG__min_dT_TestBT_ToAfterPlate->Integral());
 
        canv_SG_2->cd(8);
        var_NN__SG__min_dR_TestBT_ToAfterPlate->Draw();
        var_NN__SG__min_dR_TestBT_ToAfterPlate->SetLineColor(2);
        var_NN__SG__min_dR_TestBT_ToAfterPlate->Scale(1.0/var_NN__SG__min_dR_TestBT_ToAfterPlate->Integral());
        var_NN__BG__min_dR_TestBT_ToAfterPlate->Draw("same");
        var_NN__BG__min_dR_TestBT_ToAfterPlate->SetLineColor(4);
        var_NN__BG__min_dR_TestBT_ToAfterPlate->Scale(1.0/var_NN__BG__min_dR_TestBT_ToAfterPlate->Integral());
 
 
        canv_SG_2->cd(9);
        var_NN__SG__min_dT_TestBT_To2AfterPlate->Draw();
        var_NN__SG__min_dT_TestBT_To2AfterPlate->SetLineColor(2);
        var_NN__SG__min_dT_TestBT_To2AfterPlate->Scale(1.0/var_NN__SG__min_dT_TestBT_To2AfterPlate->Integral());
        var_NN__BG__min_dT_TestBT_To2AfterPlate->Draw("same");
        var_NN__BG__min_dT_TestBT_To2AfterPlate->SetLineColor(4);
        var_NN__BG__min_dT_TestBT_To2AfterPlate->Scale(1.0/var_NN__BG__min_dT_TestBT_To2AfterPlate->Integral());
 
        canv_SG_2->cd(10);
        var_NN__SG__min_dR_TestBT_To2AfterPlate->Draw();
        var_NN__SG__min_dR_TestBT_To2AfterPlate->SetLineColor(2);
        var_NN__SG__min_dR_TestBT_To2AfterPlate->Scale(1.0/var_NN__SG__min_dR_TestBT_To2AfterPlate->Integral());
        var_NN__BG__min_dR_TestBT_To2AfterPlate->Draw("same");
        var_NN__BG__min_dR_TestBT_To2AfterPlate->SetLineColor(4);
        var_NN__BG__min_dR_TestBT_To2AfterPlate->Scale(1.0/var_NN__BG__min_dR_TestBT_To2AfterPlate->Integral());
 
        canv_SG_2->cd(11);
        var_NN__SG__zDiff_TestBT_To_InBT->Draw();
        var_NN__SG__zDiff_TestBT_To_InBT->SetLineColor(2);
        var_NN__SG__zDiff_TestBT_To_InBT->Scale(1.0/var_NN__SG__zDiff_TestBT_To_InBT->Integral());
        var_NN__BG__zDiff_TestBT_To_InBT->Draw("same");
        var_NN__BG__zDiff_TestBT_To_InBT->SetLineColor(4);
        var_NN__BG__zDiff_TestBT_To_InBT->Scale(1.0/var_NN__BG__zDiff_TestBT_To_InBT->Integral());
 
 
        canv_SG_2->cd(12);
        var_NN__SG__dR_TestBT_To_InBT->Draw();
        var_NN__SG__dR_TestBT_To_InBT->SetLineColor(2);
        var_NN__SG__dR_TestBT_To_InBT->Scale(1.0/var_NN__SG__dR_TestBT_To_InBT->Integral());
        var_NN__BG__dR_TestBT_To_InBT->Draw("same");
        var_NN__BG__dR_TestBT_To_InBT->SetLineColor(4);
        var_NN__BG__dR_TestBT_To_InBT->Scale(1.0/var_NN__BG__dR_TestBT_To_InBT->Integral());
 
 
 
        TCanvas* canv_BG = new TCanvas("canv_BG","canv_BG",800,800);
        simu_SG->Write();
        simu_BG->Write();
        simu->Write();
        canv_SG->Write();
        canv_SG_2->Write();
        fil->Close();
        delete fil;
 
    } // Train=TRUE
 
 
    return;
}

ReconstructShowers_OI()

void ReconstructShowers_OI

(

)

void ReconstructShowers_CL() /// Still Missing in the Implementation !!!

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_OI() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of OFFICIAL IMPLEMENTATION Algorithm
    //-----------------------------------------------------------------
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        if (gEDBDEBUGLEVEL==1) {
            int modulo=TMath::Max(GLOBAL_InBTArrayEntries/20,1);
            if ((i%modulo)==0) cout << i <<" : 5% more done"<<endl;
        }
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
 
        /*
        //-----------------------------------
                // 1) BG Clean of local_gAli
        // that maybe not necessary always , only for the large
        // MC pasted Backgrounds...
                //-----------------------------------
        Float_t BGTargetDensity=0;
        //      cout << "---      \t\t :     -CLEAN     InputData BG Cleaning: 0: No, 1:20BT/mm2  2: 40BT/mm2  3:10BT/mm2 4:60BT/mm2 \n";
        if (cmd_CLEAN==1) BGTargetDensity=20;
        if (cmd_CLEAN==2) BGTargetDensity=40;
        if (cmd_CLEAN==3) BGTargetDensity=10;
        if (cmd_CLEAN==4) BGTargetDensity=60;
        if (cmd_CLEAN==0) BGTargetDensity=1000;
 
        EdbPVRQuality* localPVRQualCheck = new EdbPVRQuality(local_gAli,BGTargetDensity);
        EdbPVRec* new_local_gAli;
        new_local_gAli = localPVRQualCheck->GetEdbPVRec(1);
        localPVRQualCheck->Print();
        local_gAli=new_local_gAli;
        */
 
//              InBT->PrintNice();
//              gSystem->Exit(1);
 
        //-----------------------------------
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
            for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                // Now apply cut conditions: OFFICIAL IMPLEMENTATION Alg  --------------------
                if (!GetConeOrTubeDistanceToInBT(seg, InBT, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                if (!FindPrecedingBTsSingleThetaAngle(seg, InBT, local_gAli, GLOBAL_ShowerSegArray)) continue;
                // end of    cut conditions: OFFICIAL IMPLEMENTATION Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                if (seg->X()==InBT->X()&&seg->Y()==InBT->Y()) {
                    ;    // do nothing;
                }
                else {
                    GLOBAL_ShowerSegArray -> Add(seg);
                }
            }
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
        }
        // end of loop over all plates of local_gAli
        if (gEDBDEBUGLEVEL>2)  PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

ReconstructShowers_OI2()

void ReconstructShowers_OI2

(

)

DEPRECIATED !!!!

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_OI2() --- DEPRECIATED !!!!   RETURN !!!");
    return;
}

ReconstructShowers_OPENMP()

void ReconstructShowers_OPENMP

(

)

                                 {
    cout << endl << "=======================================================" << endl << endl;
    gEDBDEBUGLEVEL=3;
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    cout << "GLOBAL_InBTArrayEntries = " << GLOBAL_InBTArrayEntries << endl;
    int tid=0;
    int i=0;
    int nthreads=0;
    int chunk=2;
 
    #pragma omp parallel shared(nthreads) private(i,tid)
    {
        //      cout << "tid = omp_get_thread_num() " <<  omp_get_thread_num() << endl;
        if (tid == 0)
        {
            //          nthreads = omp_get_num_threads();
            printf("Number of threads = %d\n", nthreads);
        }
 
        printf("Thread %d starting...\n",tid);
 
        PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
        cout << endl;
 
        #pragma omp for
        for (Int_t ii=GLOBAL_InBTArrayEntries-1; ii>=0; --ii) {
            EdbSegP* seg = (EdbSegP*) GLOBAL_InBTArray -> At(ii);
            printf("Thread %d: %i execute now ReconstructShowers_OPENMP_TEST \n",tid,ii);
            seg->PrintNice();
            TObjArray LOCAL_ShowerSegArray;
            ReconstructShowers_OPENMP_TEST(seg, LOCAL_ShowerSegArray);
            printf("Thread %d: %i  %d entires in LOCAL_ShowerSegArray: \n",tid,ii,LOCAL_ShowerSegArray.GetEntries() );
        }
 
    }  /* end of parallel section */
 
 
    // endo of OPENMP_session
    return;
}

ReconstructShowers_OPENMP_TEST()

void ReconstructShowers_OPENMP_TEST	(	EdbSegP *	InBT,
		TObjArray	array
	)

DEBUG OPENMP TEST!!!!!!!

                                                                    {
 
    // Dummy Function: Create 4 Segments just by propagating to 2=2,3,4,5*InBT->Z();
    array.Add(InBT);
    for (Int_t j=0; j<3; ++j) {
        cout << "   j = " << j << endl;
        EdbSegP* s=new EdbSegP(j,InBT->X(),InBT->Y(),InBT->TX(),InBT->TY());
        s->SetZ(InBT->Z());
        s->PropagateTo((j+1)*1300+InBT->Z());
        s->SetMC(InBT->MCEvt(),InBT->MCEvt());
        s->PrintNice();
        array.Add(s);
    }
    //PrintShowerObjectArray(array);
 
    cout << " Since GLOBAL_ShowerSegArray is global we SHOULD expect here parallel conflicts !!!! " << endl;
    return;
}

ReconstructShowers_RC()

void ReconstructShowers_RC

(

)

last to variables are dummyvariabes.

if this is in, it doesnt work for iteratet ShowerAxisCenterGravityBT

last to variables are dummyvariabes.

if this is in, it doesnt work for iteratet ShowerAxisCenterGravityBT

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_RC() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of "Recursive Cone" Algorithm
    //-----------------------------------------------------------------
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        Int_t btloop_cnt_N=0;
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
            btloop_cnt_N=local_gAli->GetPattern(patterloop_cnt)->GetN();
 
            // if pattern is before the Initiator BT->Z() position we just go on:
            if (local_gAli->GetPattern(patterloop_cnt)->Z()<InBT->Z()) continue;
 
            for (Int_t btloop_cnt=0; btloop_cnt<btloop_cnt_N; ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                // Now apply cut conditions: RECURSIVE CONE Alg  --------------------
                if (!GetConeOrTubeDistanceToBTOfShowerArray(seg, InBT, GLOBAL_ShowerSegArray, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                if (!FindPrecedingBTsSingleThetaAngle(seg, InBT, local_gAli, GLOBAL_ShowerSegArray)) continue;
                // end of    cut conditions: RECURSIVE CONE Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                AddBTToArrayWithCeck(seg, GLOBAL_ShowerSegArray);
            }
 
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
        }
        // end of loop over all plates of local_gAli
 
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
        Int_t f_NBT=0;
        Int_t f_NBTMC=0;
        Int_t f_NBTallMC=0;
        Int_t f_NBTeMC=0;
        Double_t  f_eff=0;
        Double_t f_purall=0;
        Double_t f_pure=0;
        CalcEffPurOfShower(GLOBAL_ShowerSegArray, f_NBT, f_NBTMC, f_NBTallMC, f_NBTeMC, f_purall, f_pure);
 
        //-----------------------------------
        // 3) Try RE-ITERATION over (whole) local_gAli!!
        // 3) Using the iterated shower Gravity Center!
        // 3)
        // 3) WILL NOT WORK FOR ELECTRONS ... CAUSE FISRT POSITION IS SHIFTED AFTER ITERATION !!!
        // 3) DEPRECIAPTED
        // 3) DEPRECIAPTED  .... DO NOT USE IT NOW!!!!!!!!!!!!!!
        // 3) DEPRECIAPTED  (even if it works we dont need to reevaluate the
        // 3)                efficency numbers anymore, since calculated above)
        //-----------------------------------
 
        Bool_t DoIteration=kFALSE;
        //          Bool_t DoIteration=kTRUE// 3) DEPRECIAPTED  .... DO NOT USE IT NOW!!!!!!!!!!!!!!
 
        if (DoIteration) {
 
            cout << "-------------------------------------------"<<endl;
            EdbSegP* ShowerAxisCenterGravityBT = BuildShowerAxis(GLOBAL_ShowerSegArray);
            GLOBAL_ShowerSegArray->Clear();
            //-----------------------------------
            // 3) Loop again over (whole) local_gAli, check BT for Cuts
            //-----------------------------------
            local_gAli_npat=local_gAli->Npatterns();
            btloop_cnt_N=0;
            if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
            // Loop over all plates of local_gAli, since this is already
            // extracted with the right numbers of plates...
            for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
                if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
                btloop_cnt_N=local_gAli->GetPattern(patterloop_cnt)->GetN();
 
                for (Int_t btloop_cnt=0; btloop_cnt<btloop_cnt_N; ++btloop_cnt) {
                    seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                    if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                    // Now apply cut conditions: RECURSIVE CONE Alg  --------------------
                    //                  if (!GetConeOrTubeDistanceToBTOfShowerArray(seg, ShowerAxisCenterGravityBT, GLOBAL_ShowerSegArray, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                    if (!FindPrecedingBTsSingleThetaAngle(seg, ShowerAxisCenterGravityBT, local_gAli, GLOBAL_ShowerSegArray)) continue;
                    // end of    cut conditions: RECURSIVE CONE Alg  --------------------
 
                    // If we arrive here, Basetrack seg has passed criteria
                    // and is then added to the shower array:
                    // Check if its not the InBT which is already added:
                    //                  if (seg->X()==ShowerAxisCenterGravityBT->X()&&seg->Y()==ShowerAxisCenterGravityBT->Y()) { ; } // do nothing;
                    //                  else {GLOBAL_ShowerSegArray -> Add(seg);}
                    AddBTToArrayWithCeck(seg, GLOBAL_ShowerSegArray);
                }
            }
            // end of loop over all plates of local_gAli
            if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
            cout << "-------------------------------------------"<<endl;
 
 
        } // of if (DoIteration)
 
        Int_t s_NBT=0;
        Int_t s_NBTMC=0;
        Int_t s_NBTallMC=0;
        Int_t s_NBTeMC=0;
        Double_t  s_eff=0;
        Double_t s_purall=0;
        Double_t s_pure=0;
        CalcEffPurOfShower(GLOBAL_ShowerSegArray, s_NBT, s_NBTMC, s_NBTallMC, s_NBTeMC, s_purall, s_pure);
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //-----------------------------------
        // 7) cout some numbers from shower reco:
        //-----------------------------------
        if (gEDBDEBUGLEVEL>2) {
            cout << "-------------------------------  _NUMBERS ----------------------"<<endl;
            cout << "ITERATION 0 : --- NBT    = " << f_NBT << endl;
            cout << "ITERATION 0 : --- NBTMC  = " << f_NBTMC << endl;
            cout << "ITERATION 0 : --- purall = " << f_purall << endl;
            cout << "------------"<<endl;
            cout << "ITERATION 1 : --- NBT    = " << s_NBT << endl;
            cout << "ITERATION 1 : --- NBTMC  = " << s_NBTMC << endl;
            cout << "ITERATION 1 : --- purall = " << s_purall << endl;
            cout << "NUMBERS  " << f_NBT << " " <<  f_NBTMC << " " <<  f_purall << " " <<  s_NBT << " " <<  s_NBTMC << " " <<  s_purall << " " << endl;
        }
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

ReconstructShowers_SA()

void ReconstructShowers_SA

(

)

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_SA() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of SA Algorithm : only MCEvents with different cuts on MC parameters
    //-----------------------------------------------------------------
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 3) Loop over (whole) local_gAli, check BT for Cuts
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        //local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
        local_gAli = TransformEdbPVRec_SA(GLOBAL_gAli, InBT); // Especially for SA-Algorithm to set the size of the local_gAli also.
 
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
 
        //-----------------------------------
        // 2) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
            for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                // Now apply cut conditions: ReconstructShowers_SA Alg  --------------------
                if (seg->MCEvt()<0) continue;
                if (seg->P() < CUT_PARAMETER[0]) continue;
                // end of    cut conditions: ReconstructShowers_SA Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                if (seg->X()==InBT->X()&&seg->Y()==InBT->Y()) {
                    ;    // do nothing;
                }
                else {
                    GLOBAL_ShowerSegArray -> Add(seg);
                }
            }
 
            // Calc BT density around shower:
            EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
            CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
 
            // Calc TrackNumbers for plate for efficency numbers:
            CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
        }
        // end of loop over all plates of local_gAli
        if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

ReconstructShowers_TC()

void ReconstructShowers_TC

(

)

{
    Log(2, "ShowRec.cpp", "--- void ReconstructShowers_TC() ---");
 
    //-----------------------------------------------------------------
    // Main function for reconstruction of TC "Track(s) (in) Cone" Algorithm
    // Connects tracks to ConteTube Reconstructed Object like in the CA or OI Alg.
    //-----------------------------------------------------------------
 
    //-----------------------------------
    // For each InitiatorBT this is
    // divided in several small parts:
    //
    // 1) Make local_gAli with cut parameters, Make GetPID of InBT and corresponding of plates
    // 2a) Loop over (whole) local_gAli, check BT for Cuts (ConeTube)
    // 2b) Loop over (whole) tracks from a linked_tracks file, try to attach these tracks to BT of these within the cone
    // 2c) Loop over (whole) attached basetracks, start ConeTube Reconstruction for these BT itsself.
    // 4) Calculate pur/eff/NBT numbers
    // 5) Fill Trees
    //-----------------------------------
 
    // Define Helper Variables:
    EdbPVRec* local_gAli;
    EdbSegP* InBT;
    EdbSegP* seg;
    Float_t local_gAli_pat_interim_halfsize=0;
 
    GLOBAL_InBTArrayEntries=GLOBAL_InBTArray->GetEntries();
    GLOBAL_INBTSHOWERNR=0;
 
    Float_t gAliZMax=TMath::Max(GLOBAL_gAli->GetPattern(GLOBAL_gAli->Npatterns()-1)->Z(),GLOBAL_gAli->GetPattern(0)->Z());
 
    if (gEDBDEBUGLEVEL>2) {
        cout << "--- --- --- Printing GLOBAL_InBTArray  MaximumZ Position " << gAliZMax << "  --- --- ---"<<endl;
        PrintShowerObjectArray(GLOBAL_InBTArray);
    }
 
    // Define TObjArray which contains Bastracks Clones from the tracking.
    EdbSegP * segment=0;
    EdbSegP * s2=0;
    EdbTrackP  *t  = 0;
    TFile * fil = new TFile("linked_tracks.root");
    TTree* tr= (TTree*)fil->Get("tracks");
    TClonesArray *segClonesArray= new TClonesArray("EdbSegP",60);
    int nentr = int(tr->GetEntries());
    int nseg,n0,npl;
    cout << "Of linked_tracks we have " << nentr << "  entries Total"<<endl;
    tr->SetBranchAddress("t."  , &t  );
    tr->SetBranchAddress("s"  , &segClonesArray  );
    tr->SetBranchAddress("nseg"  , &nseg  );
    tr->SetBranchAddress("n0"  , &n0  );
    tr->SetBranchAddress("npl"  , &npl  );
    if (gEDBDEBUGLEVEL>2) tr->Show(0);
 
    cout << "Try Creating Arrays"<< endl;
    TObjArray* LOCAL_TrackBTArray= new TObjArray(nentr);
    TObjArray* LOCAL_NewAddedBTArray= new TObjArray(nentr);
    cout << "Creating Arrays done."<< endl;
 
    for (int i=0; i<nentr; i++ ) {
        //if (i%10!=0) continue;
        tr->GetEntry(i);
 
        if (gEDBDEBUGLEVEL>3) cout << i << "    t.eX Y Z " << t->X() << "   "<< t->Y() << "   "<< t->Z() << endl;
 
        // // Take only Basetracks from tracks which pass 3 or more plates:
        // if (npl<3) continue;
 
 
        // Take only tracks which are inside the gAli Volume:
        // Cause Linking is done with all 57 plates, but reconstruction can be done of coure on less:
        s2=(EdbSegP*) segClonesArray->At(nseg-1);
        if (s2->Z()>gAliZMax) {
            cout << " TrackEND is outside of gALi Volume!  Dont take track." << endl;
            continue;
        }
 
        //       CUTPARAMETER[6]=CUT_TRACKATTACH_NTRACKSEG
        //       CUT_TRACKATTACH_NTRACKSEG ranges from [0..nseg-2]
        //       nseg ranges from [2..nseg-1]
 
        int takeN=TMath::Min(nseg-1,int(CUT_PARAMETER[6])+1);
        //cout << " takeN =  " << takeN << endl;
 
        for (int hh=0; hh<takeN; hh++) {
            // Take first BT of the tracks:
            s2=(EdbSegP*) segClonesArray->At(hh);
            if (gEDBDEBUGLEVEL>3) s2->PrintNice();
 
            // Note: here we take all tracks, regardingless if they are in our desired range. (FP,MP,LP)
            // This we check further down:
            // Clone segment, otherwise it will be overwritten by the next.
            segment=(EdbSegP*)s2->Clone();
            // Add it to LOCAL_TrackBTArray
            LOCAL_TrackBTArray->Add(segment);
        }
        //cout << "for (int hh=0; hh<takeN; hh++) done."<<endl;
 
    }
    delete tr;
    delete fil;
 
    if (gEDBDEBUGLEVEL>1) cout << "--- Filled " << LOCAL_TrackBTArray->GetEntries()  << " Segments into LOCAL_TrackBTArray."<<endl;
 
 
    //-----------------------------------------------------------------
    // Since GLOBAL_InBTArray is filled in ascending ordering by zpositon
    // We use the descending loop to begin with BT with lowest z first.
    // This part of the Algorithm is the same as OI Alg part:
    for (Int_t i=GLOBAL_InBTArrayEntries-1; i>=0; --i) {
 
        //-----------------------------------
        // CounterOutPut
        if (gEDBDEBUGLEVEL==2) if ((i%1)==0) cout << GLOBAL_InBTArrayEntries <<" InBT in total, still to do:"<<Form("%4d",i)<< "\r\r\r\r"<<flush;
        //-----------------------------------
 
        //-----------------------------------
        // Get InitiatorBT from GLOBAL_InBTArray
        InBT=(EdbSegP*)GLOBAL_InBTArray->At(i);
        //--------
        GLOBAL_InBT_E=InBT->P();
        GLOBAL_InBT_TanTheta=TMath::Sqrt(InBT->TX()*InBT->TX()+InBT->TY()*InBT->TY());
        GLOBAL_InBT_Flag=InBT->Flag();
        GLOBAL_InBT_MC=InBT->MCEvt();
        //--------
        Int_t local_NBT=0;
        Int_t local_NBTMC=0;
        Int_t local_NBTallMC=0;
        Int_t local_NBTeMC=0;
        float_t local_pure=-1;
        float_t local_purall=-1;
        Int_t npat_int=0;
        Int_t npat_total=0;
        Int_t npatN=0;
        Int_t npat_Neff=0;
        Int_t NBT_Neff=0;
        Int_t NBTMC_Neff=0;
        Int_t NBTMCe_Neff=0;
        //--------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << endl << endl << "--- Starting Shower for Number " << i << " now: "<<endl;
            InBT->PrintNice();
            cout << " InBT->MCEvt()  "<< InBT->MCEvt()  << "   InBT->P()  " << InBT->P()  << endl;
        }
        //-----------------------------------
 
        //-----------------------------------
        // 1) Make local_gAli with cut parameters:
        //-----------------------------------
        local_gAli = TransformEdbPVRec(GLOBAL_gAli, InBT);
        //local_gAli = TransformEdbPVRec_SA(GLOBAL_gAli, InBT); // Especially for SA-Algorithm to set the size of the local_gAli also.
 
        // Add InBT to GLOBAL_ShowerSegArray
        GLOBAL_ShowerSegArray -> Add(InBT);
        //-----------------------------------
 
 
        //-----------------------------------
        // 2a) Loop over (whole) local_gAli, check BT for Cuts
        //-----------------------------------
        Int_t local_gAli_npat=local_gAli->Npatterns();
        if (gEDBDEBUGLEVEL>2) cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
        // Loop over all plates of local_gAli, since this is already
        // extracted with the right numbers of plates...
        for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
            if (gEDBDEBUGLEVEL>3) cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
 
            for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
                seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                // Now apply cut conditions: TrackCone Alg  --------------------
                // (for first iteration, thi is equivalent to OI Alg Implementation:
                //         if (GetdeltaRWithPropagation(seg,InBT)>100) continue;
                //         if (TMath::Abs(seg->Z()-InBT->Z())>5000) continue;
                if (!GetConeOrTubeDistanceToInBT(seg, InBT, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                if (!FindPrecedingBTsSingleThetaAngle(seg, InBT, local_gAli, GLOBAL_ShowerSegArray)) continue;
                // end of    cut conditions: TrackCone IMPLEMENTATION Alg  --------------------
 
                // If we arrive here, Basetrack seg has passed criteria
                // and is then added to the shower array:
                // Check if its not the InBT which is already added:
                AddBTToArrayWithCeck(seg,  GLOBAL_ShowerSegArray);
            }
 
        }  // end of loop over all plates of local_gAli
//     if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
 
        Float_t NBT_before=0;
        Float_t NBT_after=0;
        Float_t NBTMC_before=0;
        Float_t NBTMC_after=0;
        Float_t pur_before=0;
        Float_t pur_after=0;
 
        // Quickly calculate NEW NBT and pur------------------------
        EdbSegP* interim=0;
        for (int count=0; count<GLOBAL_ShowerSegArray->GetEntries(); count++) {
            NBT_before++;
            interim=(EdbSegP*)GLOBAL_ShowerSegArray->At(count);
            if (interim->MCEvt()>0) NBTMC_before++;
        }
        pur_before=(Float_t)NBTMC_before/(Float_t)NBT_before;
        // Quickly calculate NEW NBT and pur------------------------
 
 
 
        //-----------------------------------
        // 2b) Loop over (whole) tracks from a linked_tracks file, try to attach these tracks to BT of these within the cone
        // wARNING,wARNING: the linked tracks root file BaseTrack PIDs  and the PIDs of the BTs in the eAli DO NOT
        // NECESSARILY have to be identical, so please, make comparisons rather on Z instead on PID.
        //-----------------------------------
 
 
        //cout << "=============================================================================="<<endl;
        //cout << "=" << endl;
        //cout << "=   NOW try to attach tracks to the reconstructed showers:" << endl;
 
        // Clear LOCAL_NewAddedBTArray to have only same MCEvts in it:
        LOCAL_NewAddedBTArray->Clear();
 
        int nentr_LOCAL_TrackBTArray=LOCAL_TrackBTArray->GetEntries();
        int nentr_GLOBAL_ShowerSegArray=GLOBAL_ShowerSegArray->GetEntries();
 
        int  nentr2=nentr_LOCAL_TrackBTArray;
 
        EdbSegP* tryAttachedSegment=0;
        EdbSegP* alreadyTakenSegment=0;
 
        for (Int_t icount=0; icount<nentr2; icount++ ) {
            //for(int icount=nentr2/2; icount<(nentr2/2)+2; icount++ ) {
 
            tryAttachedSegment=(EdbSegP*)LOCAL_TrackBTArray->At(icount);
 
            // But take only segemnst with same MC Number as InBT of course!!
            if (tryAttachedSegment->MCEvt()>0 && tryAttachedSegment->MCEvt()!=InBT->MCEvt()) continue;
 
            //cout << "Try to attac now segment (if array) " << icount << " with: " << endl;
            //tryAttachedSegment->PrintNice();
            //cout << "to any of the already attached segments: " << endl;
 
            for (Int_t j=0; j<GLOBAL_ShowerSegArray->GetEntries(); j++ ) {
                alreadyTakenSegment=(EdbSegP*)GLOBAL_ShowerSegArray->At(j);
 
                Float_t dRTEST= GetdeltaRWithPropagation(tryAttachedSegment,alreadyTakenSegment);
                Float_t dMinDist=GetMinimumDist(tryAttachedSegment,alreadyTakenSegment);
                Float_t dMinDist_DT=GetdeltaThetaSingleAngles(tryAttachedSegment,alreadyTakenSegment);
 
                /*
                if (gEDBDEBUGLEVEL>2) {
                cout << "     Test GLOBAL_ShowerSegArray segment (if array) " << j << " with: " << endl;
                alreadyTakenSegment->PrintNice();
                cout << "     to connect: deltaRWith Propagation (tryAttachedSegment,alreadyTakenSegment) : ";
                cout << dRTEST;
                cout << "     GetMinimumDist(tryAttachedSegment,alreadyTakenSegment) : " << dMinDist << " " << dMinDist_DT << endl;
                }
                */
 
                // The testing trackBT has to satisfy both criteria:
                // minimum Distance and deltaThetaSingleAngels
                // CUT_PARAMETER[4]=CUT_TRACKATTACH_DISTMIN
                // CUT_PARAMETER[5]=CUT_TRACKATTACH_DTAN_MAX
                if (dMinDist< CUT_PARAMETER[4] && dMinDist_DT< CUT_PARAMETER[5]) {
                    LOCAL_NewAddedBTArray->Add(tryAttachedSegment);
                    //if (gEDBDEBUGLEVEL>2) cout << "Found a close connection. Add tryAttachedSegment to  LOCAL_NewAddedBTArray"<<endl;
                    break;
                }
 
            } // of (int j=0;)
        } // of (int icount=0; );
 
        //cout << "LOCAL_NewAddedBTArray->GetEntries()  = " << LOCAL_NewAddedBTArray->GetEntries() << endl;
        //cout << "=" << endl;
        //cout << "=============================================================================="<<endl;
 
 
        //-----------------------------------
        // 2c) Loop over (whole) local_gAli, again, but now with ONLY the new LOCAL_NewAddedBTArray as starting BTs
        // 2c) and only if the local_gAli Z position id greater equal than LOCAL_NewAddedBTArray z position:
        // 2c) Do this for every new added BaseTrack:
        // 2c) Rember that not the BaseTracks of the linked_tracks.root file are NOT given into ShowerOject array,
        // 2c) Only the intrinsic ones which come out from the gAli directly.
        // 2c) This is to avoid duplication of tracks, since the may not be totally equal in X,Y,Z
        // 2c) For example if tracking was done with small different par sets...
        //-----------------------------------
        //cout << " // 2c) Loop over (whole) local_gAli, again, but now with ONLY the new LOCAL_NewAddedBTArray as starting BTs"<<endl;
        //cout << " // 2c) LOCAL_NewAddedBTArray->GetEntries()  " << LOCAL_NewAddedBTArray->GetEntries() << endl;
        //PrintShowerObjectArray(LOCAL_NewAddedBTArray);
 
        for (Int_t icount=0; icount<LOCAL_NewAddedBTArray->GetEntries(); icount++) {
 
            tryAttachedSegment=(EdbSegP*)LOCAL_NewAddedBTArray->At(icount);
            if (tryAttachedSegment->MCEvt()>0 && tryAttachedSegment->MCEvt()!=InBT->MCEvt()) continue;
 
            //cout << "// 2c) Loop over (whole) local_gAli, again, but now with ONLY the new LOCAL_NewAddedBTArray as starting BTs"<< endl;
            //cout << "// 2c) and only if the local_gAli Z position id greater equal than LOCAL_NewAddedBTArray z position:"<< endl;
            //cout << " Doing this for  tryAttachedSegment  " << tryAttachedSegment->X() << " " << tryAttachedSegment->Y() << " " << tryAttachedSegment->Z() << " " << tryAttachedSegment->TX() << " " <<  tryAttachedSegment->TY() << " " << tryAttachedSegment->MCEvt() << " " << endl;
 
            local_gAli_npat=local_gAli->Npatterns();
            // cout << "--- local_gAli_npat=  " << local_gAli_npat << endl;
 
            // Loop over all plates of local_gAli, since this is already
            // extracted with the right numbers of plates...
            for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt) {
 
                float_t local_gAliZ=local_gAli->GetPattern(patterloop_cnt)->Z();
 
                //         cout << "--- --- Doing patterloop_cnt= " << patterloop_cnt << endl;
                //         cout << "--- --- local_gAli->GetPattern(patterloop_cnt)->Z()= " << local_gAliZ << endl;
                //         cout << "--- --- Is tryAttachedSegment->Z() gtreater equal local_gAliZ()= " << tryAttachedSegment->Z() << " " << local_gAliZ << endl;
 
                // We do not want to search for local_gAli which has lower Z than the attacet BT itself
                //if (tryAttachedSegment->Z() < local_gAliZ) continue;
                //if (tryAttachedSegment->Z() > local_gAliZ) continue;
 
                int matches_found=0;
                //cout << "--- --- YES its greater, searching BTs of localgAli now for matches  ?? ? GREATER OR SMALLER ???"<<endl;
 
 
                for (Int_t btloop_cnt=0; btloop_cnt<local_gAli->GetPattern(patterloop_cnt)->GetN(); ++btloop_cnt) {
                    seg = (EdbSegP*)local_gAli->GetPattern(patterloop_cnt)->GetSegment(btloop_cnt);
                    if (gEDBDEBUGLEVEL>3) seg->PrintNice();
 
                    // Now what was formerly InBT is now the new tryAttachedSegment:
                    // cout << " comparing now Segment "  << seg << "  (Z= " << seg->Z() << ")  with the tryAttachedSegment (Z= " << tryAttachedSegment->Z() << ") GetdeltaRWithPropagation: "<< GetdeltaRWithPropagation(seg,tryAttachedSegment) << endl;
 
                    // Now apply cut conditions: TrackCone Alg  --------------------
                    if (!GetConeOrTubeDistanceToInBT(seg, tryAttachedSegment, CUT_PARAMETER[0], CUT_PARAMETER[1])) continue;
                    // cout << "Passed GetConeOrTubeDistanceToInBT"<< endl;
                    if (!FindPrecedingBTsSingleThetaAngleTCDEBUG(seg, tryAttachedSegment, local_gAli, GLOBAL_ShowerSegArray)) continue;
                    //  cout << "Passed FindPrecedingBTsSingleThetaAngleTCDEBUG"<< endl;
                    // end of    cut conditions: TrackCone IMPLEMENTATION Alg  --------------------
 
                    // If we arrive here, Basetrack seg has passed criteria
                    // and is then added to the shower array:
                    // Check if its not the InBT which is already added:
                    Bool_t isBTadded=kFALSE;
                    isBTadded = AddBTToArrayWithCeck(seg,GLOBAL_ShowerSegArray);
 
                    if (gEDBDEBUGLEVEL>2) {
                        if (isBTadded) cout << "...Yes this was a new one, and is added to shower array! ..."<< endl;
                        if (isBTadded) seg->PrintNice();
                    }
                    if (isBTadded) matches_found++;
 
                } // of  (Int_t btloop_cnt=0; );
 
                //if (matches_found>0) cout << "--- --- In this plate we have found _ADDITIONAL_ (more than zero) BTs: "<< matches_found << endl;
 
                // Calculate Efficency numbers only for the last element of the loop,
                // otherwise we add to much numbers...
                if (icount==LOCAL_NewAddedBTArray->GetEntries()-1) {
                    // Calc BT density around shower:
                    EdbPattern* pat_interim=local_gAli->GetPattern(patterloop_cnt);
                    CalcTrackDensity(pat_interim,local_gAli_pat_interim_halfsize,npat_int,npat_total,npatN);
                    // Calc TrackNumbers for plate for efficency numbers:
                    CalcEfficencyNumbers(pat_interim, InBT->MCEvt(), NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
                }
 
            }  // for (Int_t patterloop_cnt=local_gAli_npat-1; patterloop_cnt>=0; --patterloop_cnt)  // end of loop over all plates of local_gAli
 
        } // for(int icount=0; icount<OCAL_NewAddedBTArray->GetEntries(); icount++ )
        LOCAL_NewAddedBTArray->Clear();
 
//      if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(GLOBAL_ShowerSegArray);
 
 
        // Quickly calculate NEW NBT and pur------------------------
        NBT_after=0;
        NBTMC_after=0;
        for (int count=0; count<GLOBAL_ShowerSegArray->GetEntries(); count++) {
            NBT_after++;
            interim=(EdbSegP*)GLOBAL_ShowerSegArray->At(count);
            if (interim->MCEvt()>0) NBTMC_after++;
        }
        pur_after=(Float_t)NBTMC_after/(Float_t)NBT_after;
        // Quickly calculate NEW NBT and pur------------------------
 
        if (gEDBDEBUGLEVEL>2) {
            cout << "  Difference between before and after: " << endl;
            cout << "  NBT =  " << NBT_after <<  "   Before: "<< NBT_before << endl;
            cout << "  NBTMC =  " << NBTMC_after <<  "   Before: "<< NBTMC_before << endl;
            cout << "  pur =  " << pur_after <<  "   Before: "<< pur_before << endl;
        }
 
        //-----------------------------------
        // 4) Calculate pur/eff/NBT numbers,
        // not needed when only reconstruction
        // done:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>=2 || cmd_OUTPUTLEVEL==0 ) {
            Int_t NBT=0;
            Int_t NBTMC=0;
            Int_t NBTallMC=0;
            Int_t NBTeMC=0;
            Double_t  eff, purall, pure;
            CalcEffPurOfShower2(GLOBAL_ShowerSegArray, NBT, NBTMC, NBTallMC, NBTeMC, purall, pure, NBT_Neff, NBTMC_Neff ,NBTMCe_Neff);
 
            // Fill only for MC Event:
            if (GLOBAL_InBT_MC>0) {
                GLOBAL_EvtBT_Flag=GLOBAL_EvtBT_FlagArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_MC=GLOBAL_EvtBT_MCArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_E=GLOBAL_EvtBT_EArray[GLOBAL_InBT_MC];
                GLOBAL_EvtBT_TanTheta=GLOBAL_EvtBT_TanThetaArray[GLOBAL_InBT_MC];
            }
            GLOBAL_trckdens=shower_trackdensb;
        }
 
 
        //-----------------------------------
        // 5) Fill Tree:
        //-----------------------------------
        TREE_ShowRecEff->Fill();
        if (gEDBDEBUGLEVEL>3) TREE_ShowRecEff->Show(TREE_ShowRecEff->GetEntries()-1);
 
 
        //-----------------------------------
        // 6a) Transfer ShowerArray to treebranchTreeEntry:
        //-----------------------------------
        if (cmd_OUTPUTLEVEL>0) {
            TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree(TREE_ShowShower,GLOBAL_ShowerSegArray);
        }
 
 
        //------------------------------------
        // Reset and delete important things:
        // also  to avoid memory problems ...
        //-----------------------------------
 
        GLOBAL_ShowerSegArray->Clear();
        if (gEDBDEBUGLEVEL>3) cout << "--- ---GLOBAL_ShowerSegArray->GetEntries(): "<< GLOBAL_ShowerSegArray->GetEntries() << endl;
        delete local_gAli;
        local_gAli=0;
        ++GLOBAL_INBTSHOWERNR;
        //------------------------------------
    }
    // end of loop over GLOBAL_InBTArrayEntries
    //-----------------------------------------------------------------
 
 
    delete LOCAL_TrackBTArray;
    delete LOCAL_NewAddedBTArray;
 
    if (gEDBDEBUGLEVEL==2) cout << endl<<flush;
    if (gEDBDEBUGLEVEL>3) cout << "---TREE_ShowRecEff->GetEntries() ... " << TREE_ShowRecEff->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3) cout << "---GLOBAL_INBTSHOWERNR ... " << GLOBAL_INBTSHOWERNR<< endl;
 
 
    return;
}

RewriteSegmentPIDs()

void RewriteSegmentPIDs

(

EdbPVRec *

gAli

)

{
    Log(3, "ShowRec.cpp", "--- void RewriteSegmentPIDs() ---");
 
    // This becomes necessary since when you have simaulation by ORFEO
    // and real measured tackground, they may have different PID() and the function
    // TransformEdbPVRec() will eventually not wor anymore since it relies on PIDs of
    // the Initiator BaseTracks, so if you start from BG Basetracks, this may crash:
    Bool_t eSGPID_To_BGPID=kFALSE;
    Bool_t eBGPID_To_SGPID=kTRUE;
 
    if (eSGPID_To_BGPID) RewriteSegmentPIDs_SGPID_To_BGPID(gAli);
    if (eBGPID_To_SGPID) RewriteSegmentPIDs_BGPID_To_SGPID(gAli);
    return;
}

RewriteSegmentPIDs_BGPID_To_SGPID()

void RewriteSegmentPIDs_BGPID_To_SGPID

(

EdbPVRec *

gAli

)

NEED TO WRITE BG PID TO GALI PIDS IF THERE ARE NO SG BT THERE !!! STILL IN EXPERIMENTAL PHASE !!!

NEED TO WRITE BG PID TO GALI PIDS IF THERE ARE NO SG BT THERE !!! STILL IN EXPERIMENTAL PHASE !!!

{
 
    // This function is inteded if you have mixture of Simulation and Data, some
    // of the values are not equally filled, and here the affected PID are made
    // same.
 
    // If during the read in procedure (via lnk.lst lnk.def the segments are automatically
    // assigned new values, then this is not necessary!
 
    /*
    EdbPatternsVolume with 11 patterns
    id=  0 pid=  0   x:y:z =         0.000        0.000    13000.025  n=     1001
    id=  1 pid=  1   x:y:z =         0.000        0.000    11700.037  n=      994
    id=  2 pid=  2   x:y:z =         0.000        0.000    10399.992  n=      983
    id=  3 pid=  3   x:y:z =         0.000        0.000     9100.037  n=     1039
    id=  4 pid=  4   x:y:z =         0.000        0.000     7800.044  n=      532
    id=  5 pid=  5   x:y:z =         0.000        0.000     6500.041  n=      964
    id=  6 pid=  6   x:y:z =         0.000        0.000     5200.023  n=      904
    id=  7 pid=  7   x:y:z =         0.000        0.000     3900.070  n=      823
    id=  8 pid=  8   x:y:z =         0.000        0.000     2600.014  n=      782
    id=  9 pid=  9   x:y:z =         0.000        0.000     1300.052  n=      783
    id= 10 pid= 10   x:y:z =         0.000        0.000        0.000  n=      681
 
    There should be         PID(firstplate) always 1
    There should be         PID(lastplate) always npatters-1
 
    There is a difference between the pid of the EdbPatternsVolume and the PID() of
    the segment couples,
    but at the point where the EdbPatternsVolume is read in, the information on the
    PID() of s.ePID is overwritten.
    Example: Basetracks of 01.cp.root have s.ePID==1 for Sim Basetracks
    after reading in, here they have  pid= 10
 
    For our simulated data this has alrady written in at reconstruction level:
    segments of 01_001.cp.root have PID()==1                (z==0)
    segments of 56_001.cp.root have PID()==56               (Z==71200)
    segments of 57_001.cp.root have PID()==57               (Z==72500) [but pl 57 not existing in simulation]
    But for data from BG scannings this is arbitrarily (mostly zero)
    So we set this automatically here:
    */
 
 
    //  return;
    Log(3, "ShowRec.cpp", "--- void RewriteSegmentPIDs_BGPID_To_SGPID() ---");
 
 
    Log(2, "ShowRec.cpp", "--- void RewriteSegmentPIDs_BGPID_To_SGPID() --- returning, because no good implementation for this function yet........");
    return;
 
    Int_t npat = gAli->Npatterns();
    Int_t nseg =0;
    Int_t nominal_PID_SG=1234567890;
    Int_t nominal_PID_gALI=1234567890;
 
    EdbSegP* testseg=0;
 
    cout << "==============DEBUG====================="<<endl;
 
    gAli->GetPattern(0)->GetSegment(0)->Print();
 
    gAli->GetPattern(npat-1)->GetSegment(0)->Print();
 
 
    //  return;
 
    gAli->Print();
 
 
    //  for (Int_t i=0; i<npat; ++i){
    for (Int_t i=0; i<npat; ++i) {
        nseg=gAli->GetPattern(i)->N();
 
 
        cout << "gAli->GetPattern(i)->PID= " << gAli->GetPattern(i)->PID() <<  endl;
        nominal_PID_gALI=gAli->GetPattern(i)->PID();
 
        cout << "this is for MCEV>0" << endl;
 
        for (Int_t ii=0; ii<nseg; ++ii) {
            testseg=(EdbSegP*)gAli->GetPattern(i)->GetSegment(ii);
            if (testseg->MCEvt()<0) continue;
            cout << "PID of (MC) testseg = " << testseg->PID()<< endl;
            //          testseg->Print();
            break;
        }
 
        cout << "this is for MCEV<0" << endl;
 
        for (Int_t ii=0; ii<nseg; ++ii) {
            testseg=(EdbSegP*)gAli->GetPattern(i)->GetSegment(ii);
            if (testseg->MCEvt()>0) continue;
            cout << "PID of (MC) testseg = " << testseg->PID()<< endl;
            //          testseg->Print();
            break;
        }
 
        /*
        //      for (Int_t ii=0; ii<nseg; ++ii){
        Bool_t found_SG_BT=kFALSE;
        Int_t ii=0;
        while (found_SG_BT==kFALSE) {
        testseg=(EdbSegP*)gAli->GetPattern(i)->GetSegment(ii);
        if (testseg->MCEvt()<0) continue;
        cout << "PID of (MC) testseg = " << testseg->PID()<< endl;
        testseg->Print();
        ++ii;
        found_SG_BT=kTRUE;
        }
 
        Bool_t found_BG_BT=kFALSE;
        ii=0;
        while (found_BG_BT==kFALSE) {
        testseg=(EdbSegP*)gAli->GetPattern(i)->GetSegment(ii);
        if (testseg->MCEvt()>0) continue;
        cout << "PID of (MC) testseg = " << testseg->PID()<< endl;
        testseg->Print();
        ++ii;
        found_BG_BT=kTRUE;
        }
        */
 
 
        /*
 
 
        nominal_PID_SG=i+1; /// THIS DEPENDS STRONGLY ON THE STRUCTURE OF gALI OBJECT !!!!
        cout << "void RewriteSegmentPIDs_BGPID_To_SGPID()    nominal_PID_SG = " << nominal_PID_SG << " set CHECK CAREFULLY. EXPERIMENTAL HELP FUNCTION PHASE!!" << endl;
        cout << "gAli->GetPattern(i)->PID() " << gAli->GetPattern(i)->PID() << "  " << nominal_PID_SG << endl;
        cout << "gAli->GetPattern(i)->Z() " << gAli->GetPattern(i)->Z() << "  " << nominal_PID_SG << endl;
        for (Int_t ii=0; ii<nseg; ++ii){
        if (gAli->GetPattern(i)->GetSegment(ii)->MCEvt()<0) gAli->GetPattern(i)->GetSegment(ii)->SetPID(i+1);
        //          gAli->GetPattern(i)->GetSegment(ii)->Print();
        }
 
        */
    }
    return;
}

RewriteSegmentPIDs_SGPID_To_BGPID()

void RewriteSegmentPIDs_SGPID_To_BGPID

(

EdbPVRec *

gAli

)

{
    Log(3, "ShowRec.cpp", "--- void RewriteSegmentPIDs_SGPID_To_BGPID() ---");
    return;
}

SetDefaultValues_CommandLine()

void SetDefaultValues_CommandLine

(

)

                                    {
 
    Log(2, "ShowRec.cpp", "--- void SetDefaultValues_CommandLine() ---");
 
    //--- Default Values:
    cmd_PADI=0;
    cmd_BTPA=0;
    cmd_BGTP=0;
    cmd_ALTP=4;
    cmd_PASTART=-1;
    cmd_PAEND=-1;
    cmd_FP=1;
    cmd_LP=50;
    cmd_MP=25;
    cmd_NP=30;
    cmd_LT=0;
    Int_t cmd_MC=1;
    Int_t cmd_MCFL=0;
    Int_t cmd_FZHP=1;
    Int_t cmd_vtx=0;
    cmd_gEDBDEBUGLEVEL=2;
    cmd_OUTPUTLEVEL=1;
    cmd_ALI=0;
    cmd_MCMIX=0;
    cmd_FILETP=0;
    cmd_GBMC=0;
    cmd_lnkdef_name = "lnk.def";
    cmd_EXTHETA=0;
    return;
}

SortShowerZ()

void SortShowerZ

(

TObjArray *

showerarray

)

                                         {
 
    // A simple reverting sort: assuming that segments in shower are already sorted, but in
    // descending direction, so we just invert them!
    // CANNOT BE USED WHEN segments wer put in an arbitrary way!!!
 
    if (IsShowerSortedZ(showerarray)) {
        if (gEDBDEBUGLEVEL>2) cout << "Shower already sorted in ascending Z-direction. Do nothing." << endl;
        return;
    }
    Int_t nent_showerarray=showerarray->GetEntries();
    Int_t nent=showerarray->GetEntries();
    TObjArray* interimShower = new TObjArray(nent_showerarray);
    if (gEDBDEBUGLEVEL>2)   cout << "interif (gEDBDEBUGLEVEL>2)imShower->GetEntries()  " << interimShower->GetEntries()  << endl;
    if (gEDBDEBUGLEVEL>2) cout << "showerarray->GetEntries()  " << showerarray->GetEntries()  << endl;
    EdbSegP* s0;
    EdbSegP* s1;
    for (Int_t k=0; k<nent; ++k) {
        EdbSegP* s0=(EdbSegP*)showerarray->At(nent-k-1);
        interimShower->AddAt(s0,k);
    }
    showerarray->Clear();
    for (Int_t k=0; k<nent; ++k) {
        EdbSegP* s0=(EdbSegP*)interimShower->At(k);
        showerarray->AddAt(s0,k);
    }
    if (gEDBDEBUGLEVEL>2) PrintShowerObjectArray(showerarray);
 
    if (IsShowerSortedZ(showerarray)) {
        if (gEDBDEBUGLEVEL>2) cout << "Shower now sorted in ascending Z-direction. Done." << endl;
        return;
    }
    if (!IsShowerSortedZ(showerarray)) {
        cout << "WARNING   WARNING   Shower is still NOT sorted in ascending Z-direction. YOU HAVE TO CHECK MANUALLY." << endl;
        return;
    }
    return;
}

TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree()

void TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree	(	TTree *	treebranchtree,
		TObjArray *	segarray
	)

--— IMPORTANT:: these areopen cut values for best combifinding of pair BT deltaR/Theta values --— IMPORTANT:: then you do NOT necessarily get back your values which you put in durign --— IMPORTANT:: your shower reconstruction cone ( deltaR/Theta cutvalues could be NO cutvalues --— IMPORTANT:: for some reconstruction algorithms for example, but we wanna have these values anyway. In Any Case: Frederics Cut looks only for best min_shower_deltar so we do also.

--— IMPORTANT:: these areopen cut values for best combifinding of pair BT deltaR/Theta values --— IMPORTANT:: then you do NOT necessarily get back your values which you put in durign --— IMPORTANT:: your shower reconstruction cone ( deltaR/Theta cutvalues could be NO cutvalues --— IMPORTANT:: for some reconstruction algorithms for example, but we wanna have these values anyway. In Any Case: Frederics Cut looks only for best min_shower_deltar so we do also.

{
    Log(3, "ShowRec.cpp", "--- void* TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree() ---");
 
    // SaveCheck if shower has at least one basetrack:
    if (segarray->GetEntries()<1) return;
 
    EdbSegP* seg;
    EdbSegP* Inseg;
    Int_t helper_nfilmb;
    Int_t diff_pid;
    Float_t min_shower_deltathetab=99999;
    Float_t min_shower_deltar=99999;
    Float_t test_shower_deltathetab=99999;
    Float_t test_shower_deltar=99999;
    Float_t test_shower_deltax,test_shower_deltay;
    Int_t max_diff_pid=0;
 
 
    Float_t shower_sizebNHELP=0;
    Float_t shower_sizebMCNHELP=0;
 
    Float_t extrapol_x,extrapol_y, extrapo_diffz;
 
    // Initialize arrays...
    shower_sizeb15=0;
    shower_sizeb20=0;
    shower_sizeb30=0;
    shower_sizeb=0;
    shower_energy_shot_particle=0.0;
    shower_numberofilms=0;
    shower_numberofholesconseq=0;
    shower_numberofholes=0;
    shower_filetype=0;
    for (int ii=0; ii<5000; ii++)  {
        shower_xb[ii]=0;
        shower_yb[ii]=0;
        shower_zb[ii]=0;
        shower_txb[ii]=0;
        shower_tyb[ii]=0;
        shower_nfilmb[ii]=0;
        shower_tagprimary[ii]=0;
        shower_ntrace1simub[ii]=0;
        shower_ntrace2simub[ii]=0;
        shower_ntrace3simub[ii]=0;
        shower_ntrace4simub[ii]=0;
        shower_deltaxb[ii]=0;
        shower_deltayb[ii]=0;
        shower_chi2btkb[ii]=0;
        shower_idb[ii]=0;
        shower_plateb[ii]=0;
    }
    for (int i=1; i<59; ++i) {
        shower_deltasigmathetab[i]=0;
    }
 
    // Part To calculate the TransfereedVariables....
    shower_sizeb=segarray->GetEntries();
    Inseg=(EdbSegP*)segarray->At(0);
    shower_energy_shot_particle=Inseg->P();
    shower_number_eventb=Inseg->MCEvt();
    shower_filetype=cmd_FILETP;
 
 
    if (gEDBDEBUGLEVEL>3) cout << "--- --- ---------------------"<<endl;
    //-------------------------------------
    for (int ii=0; ii<shower_sizeb; ii++)  {
 
        if (ii>=5000) {
            cout << "WARNING: shower_sizeb ( " << shower_sizeb<< ") greater than SHOWERARRAY.   Set sizeb to 4999 and  Stop filling!."<<endl;
            shower_sizeb=4999;
            continue;
        }
        seg=(EdbSegP*)segarray->At(ii);
 
        //-------------------------------------
        shower_xb[ii]=seg->X();
        shower_yb[ii]=seg->Y();
        shower_txb[ii]=seg->TX();
        shower_tyb[ii]=seg->TY();
        shower_zb[ii]=seg->Z();
        shower_chi2btkb[ii]=seg->Chi2();
        shower_deltathetab[ii]=0.5;
        shower_deltarb[ii]=200;
        shower_tagprimary[ii]=0;
        if (ii==0) shower_tagprimary[ii]=1;
        shower_isizeb=1; // always 1, not needed anymore
        if (seg->MCEvt()>0) {
            shower_ntrace1simub[ii]=seg->MCEvt();
            shower_ntrace2simub[ii]=seg->W();
            shower_ntrace3simub[ii]=seg->P();
            shower_ntrace4simub[ii]=seg->Flag();
        }
        else {
            // keep the seg->BT settings for BG:
            // that come out of "normal" scanned data from fedra:
            // shower_ntrace1simub=-999
            // shower_ntrace2simub=seg->W();
            // shower_ntrace3simub=-999
            // shower_ntrace4simub=0
            shower_ntrace1simub[ii]=-999;
            shower_ntrace2simub[ii]=seg->W();
            shower_ntrace3simub[ii]=-999;
            shower_ntrace4simub[ii]=0;
        }
        shower_idb[ii]=seg->ID();
        shower_plateb[ii]=seg->PID();
 
 
        //-------------------------------------
        // PUT HERE:  deltarb,deltarb, nflimb, sizeb15......
        diff_pid=TMath::Abs( Inseg->PID()-seg->PID() )+1;
        // (does this work for up/downsream listing??)
        // (yes, since InBT->PID is also changed.)
        // but works only if the gAli Object has no missing plates
        // otherwise f.e. PID(1) and PID(2) are not necessaryly abay by dZ=1300
        // (could be Z(1)=1300 and Z(2)=3900...)
 
        // Calc pur:
        // New: (16.02.2010) define purity w.r.t. MC of Initiabtor Basetrack
        // So if other MC-events (like in testbeam simulation case) had been taken, they
        // count as well as "background!"
        shower_sizebNHELP++;
        if (seg->MCEvt()==shower_number_eventb&&shower_number_eventb>0) shower_sizebMCNHELP++;
        // for example: InBT:MCEvt==4 and Basetrack has MCEvt==18 then
        // shower_sizebNHELP++, but not shower_sizebMCNHELP !!
        // But also: if shower_number_eventb==-999 i.e. we start from a BG basetrack
        // and all other shower collected BTs have MCEvt==-999 then we get also
        // a purity of 1.
        // That means shower consisting only of BG events are in that sense also "very pure".
        // How to deal with this?
        // if (shower_number_eventb=-999) then we do NOT increment
        // shower_sizebMCNHELP , this is by changing the statement from
        // if (seg->MCEvt()==shower_number_eventb) shower_sizebMCNHELP++;
        // to
        // if (seg->MCEvt()==shower_number_eventb&&shower_number_eventb>0) shower_sizebMCNHELP++;
 
        // InBT:
        if (ii==0) {
            shower_deltathetab[0]=0.5;
            shower_deltarb[0]=200;
            shower_nfilmb[0]=1;
        }
        // All other BTs:
        if (ii>0) {
            // its correct like this, since this is the way it is done in
            // the official FJ-Algorithm:
            shower_nfilmb[ii]=diff_pid;
            if (gEDBDEBUGLEVEL>3) cout << "--- ---Inseg->PID() seg->PID() ii diif_pid shower_nfilmb[ii]  " << Inseg->PID()<< "   "  <<  seg->PID() << "   " << ii<< "  " << diff_pid<<"  "<< shower_nfilmb[ii]<<"  " << endl;
 
            shower_numberofilms=TMath::Max(shower_numberofilms,diff_pid);
 
            if (diff_pid >= 15 ) shower_sizeb15++;
            if (diff_pid >= 20 ) shower_sizeb20++;
            if (diff_pid >= 30 ) shower_sizeb30++;
 
            // PUT HERE:  calculation routine for shower_deltasigmathetab
            // see referenc in thesis of Luillo Esposito, page 109.
            shower_deltasigmathetab[diff_pid]=shower_deltasigmathetab[diff_pid]+(Power(shower_txb[ii]-shower_txb[0],2)+Power(shower_tyb[ii]-shower_tyb[0],2));
 
            // PUT HERE:  calculation routine for shower_deltathetab, shower_deltarb
            // ExSetTreebranchNametrapolate the BT [ii] to the position [jj] and then calc the
            // position and slope differences;
            // For the backward extrapolation of the   shower_deltathetab and shower_deltarb
            // calulation for BaseTrack(ii), Basetrack(jj)->Z() hast to be smaller.
            min_shower_deltathetab=99999;   // Reset
            min_shower_deltar=99999;        // Reset
 
            for (int jj=0; jj<shower_sizeb; jj++)  {
                if (ii==jj) continue;
 
                // since we do not know if BTs are ordered by their Z positions:
                // and cannot cut directly on the number in the shower entry:
                // Entry jj has to have lower Z than ii:
                if (shower_zb[ii]<=shower_zb[jj]) continue;
 
                extrapo_diffz=shower_zb[ii]-shower_zb[jj];
                if (TMath::Abs(extrapo_diffz)>4*1300+1.0) continue;
//       if (TMath::Abs(extrapo_diffz)>6*1300+1.0) continue;
//               if (TMath::Abs(extrapo_diffz)>9*1300+1.0) continue;
                // if 4/6/9 gives only similar results...
                if (TMath::Abs(extrapo_diffz)<1.0) continue; // remove same positions.
 
                extrapol_x=shower_xb[ii]-shower_txb[ii]*extrapo_diffz; // minus, because its ii after jj.
                extrapol_y=shower_yb[ii]-shower_tyb[ii]*extrapo_diffz; // minus, because its ii after jj.
 
                // Delta radius we need to extrapolate.
//       test_shower_deltax=extrapol_x;//shower_txb[ii]*(shower_zb[ii]-shower_zb[jj])+shower_xb[ii];
//       test_shower_deltay=extrapol_y;//shower_tyb[ii]*(shower_zb[ii]-shower_zb[jj])+shower_yb[ii];
                test_shower_deltax=extrapol_x-shower_xb[jj];
                test_shower_deltay=extrapol_y-shower_yb[jj];
                test_shower_deltar=TMath::Sqrt(test_shower_deltax*test_shower_deltax+test_shower_deltay*test_shower_deltay);
 
                // Delta theta we do not need to extrapolate. (old version...)
                //test_shower_deltathetab=TMath::Sqrt(shower_txb[ii]*shower_txb[ii]+shower_tyb[ii]*shower_tyb[ii]);
                //test_shower_deltathetab=test_shower_deltathetab-TMath::Sqrt(shower_txb[jj]*shower_txb[jj]+shower_tyb[jj]*shower_tyb[jj]);
                //test_shower_deltathetab=TMath::Abs(test_shower_deltathetab);
                //----
                // As before in ShowRec this way of calculation is not equivalent as calculating
                // DeltaTheta domponentwise:
                // Code from libShower:
                // delta = sqrt((SX0-a->GetTXb(l2))*(SX0-a->GetTXb(l2))+((SY0-a->GetTYb(l2))*(SY0-a->GetTYb(l2))));
                test_shower_deltathetab=TMath::Sqrt(TMath::Power(shower_txb[ii]-shower_txb[jj],2)+TMath::Power(shower_tyb[ii]-shower_tyb[jj],2));
 
                // Check if both dr,dt match parameter criteria and then just take these values.....
                // Maybe a change is necessary because it is not exactly the same as in the off. algorithm.
//           if (test_shower_deltar<400 && test_shower_deltathetab<0.8 ) {
//           if (test_shower_deltar<150 && test_shower_deltathetab<0.15) {
                if (test_shower_deltar<1000 && test_shower_deltathetab<2.0 ) {
                    if (test_shower_deltar<min_shower_deltar) {
                        min_shower_deltathetab=test_shower_deltathetab;
                        min_shower_deltar=test_shower_deltar;
                        shower_deltathetab[ii]=min_shower_deltathetab;
                        shower_deltarb[ii]=min_shower_deltar;
                        //cout << ii << " " << jj << "  " << test_shower_deltathetab  << " " << test_shower_deltar << "       " <<min_shower_deltathetab << " " <<  min_shower_deltar  << endl;
 
                    }   // if (test_shower_deltar<min_shower_deltar)
                } // if (test_shower_deltar<150 && test_shower_deltathetab<0.15 )
            } // for (int jj=0;jj<shower_sizeb;jj++)
 
 
            //cout << "For ii= " << ii << "we found the best matcjgin dRtehta values: " << min_shower_deltathetab << " " <<  min_shower_deltar  << endl;
        } // if (ii>0)
        //-------------------------------------
 
 
        shower_purb=shower_sizebMCNHELP/shower_sizebNHELP;
    } //  for (int ii=0;ii<shower_sizeb;ii++)  {
    if (gEDBDEBUGLEVEL>2) {
        cout << "ShowRec.cpp     : --- void* TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree() ---"<<endl;
        cout << "Loop over for (int ii=0;ii<shower_sizeb;ii++) done." << endl;
    }
 
    //-------------------------------------
    for (int i=1; i<59; ++i) {
        shower_deltasigmathetab[i]=Sqrt(shower_deltasigmathetab[i]);
    }
    shower_numberofilms=shower_nfilmb[shower_sizeb-1]; // there we assume (this is correct always?) when
    // the last shower BT is in the last film...(otherwise we would again have to loop on sizeb array);
    //cout << "TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree   shower_numberofilms= "<< shower_numberofilms <<endl;
 
    int eN0=0;
    for (int i=0; i<shower_nfilmb[shower_sizeb-1]; i++) if (shower_nfilmb[i]==0) ++eN0;
    shower_numberofholes=eN0;
 
    int eN00int=0;
    int eN00=0;
    for (int i=1; i<shower_nfilmb[shower_sizeb-1]; i++) {
        //cout << i << "------------" << shower_nfilmb[i]-shower_nfilmb[i-1] << " --  " <<  eN00 <<  endl;
        if (shower_nfilmb[i]-shower_nfilmb[i-1]>1) {
            eN00=shower_nfilmb[i]-shower_nfilmb[i-1]-1;
            if (eN00>eN00int) eN00int=eN00;
        }
        if (shower_nfilmb[i]-shower_nfilmb[i-1]==1) eN00=0;
    }
    eN00=eN00int;
    shower_numberofholesconseq=eN00;
 
    //cout << "TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree   shower_numberofholesconseq= "<< shower_numberofholesconseq <<endl;
 
    // Also calculate now Shower axis and fill axis values into the treebranch:
//      EdbSegP* axis= new EdbSegP();
    EdbSegP* axis = BuildShowerAxis(segarray);
//      axis->PrintNice();
    //cout << "TransferShowerObjectArrayIntoEntryOfTreebranchShowerTree   BuildShowerAxis done."<<endl;
    shower_axis_xb=axis->X();
    shower_axis_yb=axis->Y();
    shower_axis_zb=axis->Z();
    shower_axis_txb=axis->TX();
    shower_axis_tyb=axis->TY();
//      delete axis;
 
    // Fill Tree:
    treebranchtree->Fill();
 
    if (gEDBDEBUGLEVEL>2) cout << "Now we have treebranchtree  Entries: "  << treebranchtree->GetEntries() << endl;
    if (gEDBDEBUGLEVEL>3)   treebranchtree->Show(treebranchtree->GetEntries()-1);
 
    return;
}

TransformEdbPVRec()

EdbPVRec* TransformEdbPVRec	(	EdbPVRec *	gAli,
		EdbSegP *	InitiatorBT
	)

DEBUG OPENMP TEST!!!!!!!

THIS IS VERY IMPORTANT, because gAliSub has to be ordered in a way that 2nd plate follows after first, since we loop in the Reconstruct_??() Alogrithms over the Basetracks already added in the shower!

---

DEBUG TEST !!! MAYBE IT GOES FASTER LIKE THIS; AND ALSO THE BG CALCULATION IS BETTER PERFORMED .....

---

THIS IS VERY IMPORTANT, because gAliSub has to be ordered in a way that 2nd plate follows after first, since we loop in the Reconstruct_??() Alogrithms over the Basetracks already added in the shower!

---

DEBUG TEST !!! MAYBE IT GOES FASTER LIKE THIS; AND ALSO THE BG CALCULATION IS BETTER PERFORMED .....

---

{
    Log(3, "ShowRec.cpp", "--- void TransformEdbPVRec() ---");
 
    //      local_halfpatternsize=11250;// debugTEST how long it takes more if we take a big area to reconstruct.
    Float_t halfpatternsize=local_halfpatternsize;
 
 
    // Informational Debug Output
    // DOWNSTREAM ORDER ASSUMED !!!
    Int_t npat = GLOBAL_gAli->Npatterns();  //number of plates
    Int_t firstplate= npat-cmd_FP;
    Int_t middleplate= npat-cmd_MP;
    Int_t actualplate= npat-cmd_FP;
    Int_t lastplate= TMath::Max(npat-cmd_LP-1,0);
    Int_t InBTplate= InitiatorBT->PID();
    Int_t InBTplateandNplate= InitiatorBT->PID()-cmd_NP+1;
    Int_t endlplatetopropagate=TMath::Max(InBTplateandNplate,lastplate);
    Float_t InBTZ= InitiatorBT->Z();
 
    if (gEDBDEBUGLEVEL>2) {
        cout << "--- TransformEdbPVRec --- DOWNSTREAM ORDER = " <<endl;
        cout << "--- TransformEdbPVRec --- npat = " << npat << endl;
        cout << "--- TransformEdbPVRec --- firstplate = " << firstplate << endl;
        cout << "--- TransformEdbPVRec --- middleplate = " << middleplate << endl;
        cout << "--- TransformEdbPVRec --- lastplate = " << lastplate << endl;
        cout << "--- TransformEdbPVRec --- InBTplate = " << InBTplate << endl;
        cout << "--- TransformEdbPVRec --- InBTplateandNplate = " << InBTplateandNplate << endl;
        cout << "--- TransformEdbPVRec --- endlplatetopropagate = " << endlplatetopropagate << endl;
        cout << "--- TransformEdbPVRec --- InBTZ = " << InBTZ << endl;
        cout << "--- TransformEdbPVRec --- InBTplate = " << InBTplate << endl;
    }
 
    // has to be deleted in some part of the script outside this function...
    // Dont forget , otherwise memory heap overflow!
    EdbPVRec* gAli_Sub = new EdbPVRec();
 
    // Create SubPattern objects
    EdbSegP* ExtrapolateInitiatorBT;
    ExtrapolateInitiatorBT = (EdbSegP*)InitiatorBT->Clone();
 
    // Create Variables For ExtractSubpattern boundaries
    Float_t mini[5];
    Float_t maxi[5];
    mini[0]=ExtrapolateInitiatorBT->X()-halfpatternsize;
    mini[1]=ExtrapolateInitiatorBT->Y()-halfpatternsize;
    maxi[0]=ExtrapolateInitiatorBT->X()+halfpatternsize;
    maxi[1]=ExtrapolateInitiatorBT->Y()+halfpatternsize;
    mini[2]=-0.5;
    mini[3]=-0.5;
    mini[4]=0.0;
    maxi[2]=0.5;
    maxi[3]=0.5;
    maxi[4]=100.0;
 
 
    if (cmd_EXTHETA==1) {
        mini[2]=ExtrapolateInitiatorBT->TX()-0.15;
        mini[3]=ExtrapolateInitiatorBT->TY()-0.15;
        maxi[2]=ExtrapolateInitiatorBT->TX()+0.15;
        maxi[3]=ExtrapolateInitiatorBT->TY()+0.15;
    }
 
    EdbPattern* singlePattern;
    Int_t MCMixFlag=-1;
    if (cmd_MCMIX==1) {
        MCMixFlag=-1;
    }
    else {
        MCMixFlag=InitiatorBT->MCEvt();
    }
 
    // Add the subpatterns in a loop for the plates:
    // in reverse ordering.due to donwstream behaviour (!):
    // (Only downstream is supported now...)
    for (Int_t ii=endlplatetopropagate; ii<=InBTplate; ++ii) {
 
        Float_t zpos=gAli->GetPattern(ii)->Z();
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Loop: ii, zpos  "<< ii  <<  "  "  << zpos << "; Print InitiatorBT,ExtrapolateInitiatorBT"<<endl;
 
        ExtrapolateInitiatorBT->PropagateTo(zpos);
        if (gEDBDEBUGLEVEL>3) {
            InitiatorBT->PrintNice();
            ExtrapolateInitiatorBT->PrintNice();
        }
 
        mini[0]=ExtrapolateInitiatorBT->X()-halfpatternsize;
        mini[1]=ExtrapolateInitiatorBT->Y()-halfpatternsize;
        maxi[0]=ExtrapolateInitiatorBT->X()+halfpatternsize;
        maxi[1]=ExtrapolateInitiatorBT->Y()+halfpatternsize;
 
        singlePattern=(EdbPattern*)gAli->GetPattern(ii)->ExtractSubPattern(mini,maxi,MCMixFlag);
//      cout << "singlePattern with MCMixFlag= " << MCMixFlag << "  nentries= " <<  singlePattern->N() << endl;
 
 
        singlePattern-> SetID(gAli->GetPattern(ii)->ID());
        singlePattern-> SetPID(gAli->GetPattern(ii)->PID());
        gAli_Sub->AddPattern(singlePattern);
    }
    if (gEDBDEBUGLEVEL>2) cout <<"--- gAli_Sub->Print():"<<endl;
    if (gEDBDEBUGLEVEL>2) gAli_Sub->Print();
    if (gEDBDEBUGLEVEL>2) cout <<"--- ----------------------------------"<<endl;
 
    return gAli_Sub;
}

TransformEdbPVRec_BackWard()

EdbPVRec* TransformEdbPVRec_BackWard	(	EdbPVRec *	gAli,
		EdbSegP *	InitiatorBT
	)

THIS IS VERY IMPORTANT, because gAliSub has to be ordered in a way that 2nd plate follows after first, since we loop in the Reconstruct_??() Alogrithms over the Basetracks already added in the shower!

THIS IS VERY IMPORTANT, because gAliSub has to be ordered in a way that 2nd plate follows after first, since we loop in the Reconstruct_??() Alogrithms over the Basetracks already added in the shower!

{
    Log(3, "ShowRec.cpp", "--- void TransformEdbPVRec_BackWard() ---");
 
    local_halfpatternsize=11250;// debugTEST how long it takes more if we take a big area to reconstruct.
    local_halfpatternsize=5000;// debugTEST how long it takes more if we take a big area to reconstruct.
    local_halfpatternsize=2000;// debugTEST how long it takes more if we take a big area to reconstruct.
    Float_t halfpatternsize=local_halfpatternsize;
 
    // Informational Debug Output
    // DOWNSTREAM ORDER ASSUMED !!!
    Int_t npat = GLOBAL_gAli->Npatterns();  //number of plates
    Int_t firstplate= npat-cmd_FP;
    Int_t middleplate= npat-cmd_MP;
    Int_t actualplate= npat-cmd_FP;
    Int_t lastplate= TMath::Max(npat-cmd_LP-1,0);
    Int_t InBTplate= InitiatorBT->PID();
    Int_t InBTplateandNplate= InitiatorBT->PID()-cmd_NP+1;
    Int_t endlplatetopropagate=TMath::Max(InBTplateandNplate,lastplate);
    Float_t InBTZ= InitiatorBT->Z();
 
    if (gEDBDEBUGLEVEL>3) {
        cout << "--- DOWNSTREAM ORDER = " <<endl;
        cout << "--- npat = " << npat << endl;
        cout << "--- firstplate = " << firstplate << endl;
        cout << "--- middleplate = " << middleplate << endl;
        cout << "--- lastplate = " << lastplate << endl;
        cout << "--- InBTplate = " << InBTplate << endl;
        cout << "--- InBTplateandNplate = " << InBTplateandNplate << endl;
        cout << "--- endlplatetopropagate = " << endlplatetopropagate << endl;
        cout << "--- InBTZ = " << InBTZ << endl;
    }
 
    // has to be deleted in some part of the script outside this function...
    // Dont forget , otherwise memory heap overflow!
    EdbPVRec* gAli_Sub = new EdbPVRec();
 
    // Create SubPattern objects
    EdbSegP* ExtrapolateInitiatorBT;
    ExtrapolateInitiatorBT = (EdbSegP*)InitiatorBT->Clone();
 
    // Create Variables For ExtractSubpattern boundaries
    Float_t mini[5];
    Float_t maxi[5];
    mini[0]=ExtrapolateInitiatorBT->X()-halfpatternsize;
    mini[1]=ExtrapolateInitiatorBT->Y()-halfpatternsize;
    maxi[0]=ExtrapolateInitiatorBT->X()+halfpatternsize;
    maxi[1]=ExtrapolateInitiatorBT->Y()+halfpatternsize;
    mini[2]=-0.5;
    mini[3]=-0.5;
    mini[4]=0.0;
    maxi[2]=0.5;
    maxi[3]=0.5;
    maxi[4]=100.0;
 
    EdbPattern* singlePattern;
 
    for (Int_t ii=0; ii<npat; ++ii) {
 
        Float_t zpos=gAli->GetPattern(ii)->Z();
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Loop: ii, zpos  "<< ii  <<  "  "  << zpos << "; Print InitiatorBT,ExtrapolateInitiatorBT"<<endl;
 
        ExtrapolateInitiatorBT->PropagateTo(zpos);
        if (gEDBDEBUGLEVEL>3) {
            InitiatorBT->PrintNice();
            ExtrapolateInitiatorBT->PrintNice();
        }
 
        mini[0]=ExtrapolateInitiatorBT->X()-halfpatternsize;
        mini[1]=ExtrapolateInitiatorBT->Y()-halfpatternsize;
        maxi[0]=ExtrapolateInitiatorBT->X()+halfpatternsize;
        maxi[1]=ExtrapolateInitiatorBT->Y()+halfpatternsize;
 
        singlePattern=(EdbPattern*)gAli->GetPattern(ii)->ExtractSubPattern(mini,maxi,InitiatorBT->MCEvt());
        singlePattern-> SetID(gAli->GetPattern(ii)->ID());
        singlePattern-> SetPID(gAli->GetPattern(ii)->PID());
        gAli_Sub->AddPattern(singlePattern);
    }
    if (gEDBDEBUGLEVEL>3) cout <<"--- gAli_Sub->Print():"<<endl;
    if (gEDBDEBUGLEVEL>3) gAli_Sub->Print();
    if (gEDBDEBUGLEVEL>3) cout <<"--- ----------------------------------"<<endl;
 
    if (gEDBDEBUGLEVEL>2) cout <<"--- gAli_Sub with ():"<< gAli_Sub->Npatterns() << "patterns."<<endl;
 
    return gAli_Sub;
}

TransformEdbPVRec_SA()

EdbPVRec* TransformEdbPVRec_SA	(	EdbPVRec *	gAli,
		EdbSegP *	InitiatorBT
	)

THIS IS VERY IMPORTANT, because gAliSub has to be ordered in a way that 2nd plate follows after first, since we loop in the Reconstruct_??() Alogrithms over the Basetracks already added in the shower!

THIS IS VERY IMPORTANT, because gAliSub has to be ordered in a way that 2nd plate follows after first, since we loop in the Reconstruct_??() Alogrithms over the Basetracks already added in the shower!

{
    Log(3, "ShowRec.cpp", "--- void TransformEdbPVRec_SA() ---");
 
    // Informational Debug Output
    // DOWNSTREAM ORDER ASSUMED !!!
    Int_t npat = GLOBAL_gAli->Npatterns();  //number of plates
    Int_t firstplate= npat-cmd_FP;
    Int_t middleplate= npat-cmd_MP;
    Int_t actualplate= npat-cmd_FP;
    Int_t lastplate= TMath::Max(npat-cmd_LP-1,0);
    Int_t InBTplate= InitiatorBT->PID();
    Int_t InBTplateandNplate= InitiatorBT->PID()-cmd_NP+1;
    Int_t endlplatetopropagate=TMath::Max(InBTplateandNplate,lastplate);
    Float_t InBTZ= InitiatorBT->Z();
 
    if (gEDBDEBUGLEVEL>2) {
        cout << "--- DOWNSTREAM ORDER = " <<endl;
        cout << "--- npat = " << npat << endl;
        cout << "--- firstplate = " << firstplate << endl;
        cout << "--- middleplate = " << middleplate << endl;
        cout << "--- lastplate = " << lastplate << endl;
        cout << "--- InBTplate = " << InBTplate << endl;
        cout << "--- InBTplateandNplate = " << InBTplateandNplate << endl;
        cout << "--- endlplatetopropagate = " << endlplatetopropagate << endl;
        cout << "--- InBTZ = " << InBTZ << endl;
    }
 
    // has to be deleted in some part of the script outside this function...
    // Dont forget , otherwise memory heap overflow!
    EdbPVRec* gAli_Sub = new EdbPVRec();
 
    // Create SubPattern objects
    EdbSegP* ExtrapolateInitiatorBT;
    ExtrapolateInitiatorBT = (EdbSegP*)InitiatorBT->Clone();
 
    Float_t halfsize=CUT_PARAMETER[1];
 
    // Create Variables For ExtractSubpattern boundaries
    Float_t mini[5];
    Float_t maxi[5];
    mini[0]=ExtrapolateInitiatorBT->X()-halfsize;
    mini[1]=ExtrapolateInitiatorBT->Y()-halfsize;
    maxi[0]=ExtrapolateInitiatorBT->X()+halfsize;
    maxi[1]=ExtrapolateInitiatorBT->Y()+halfsize;
    mini[2]=-0.5;
    mini[3]=-0.5;
    mini[4]=0.0;
    maxi[2]=0.5;
    maxi[3]=0.5;
    maxi[4]=100.0;
 
    EdbPattern* singlePattern;
 
    // Add the subpatterns in a loop for the plates:
    // in reverse ordering.due to donwstream behaviour (!):
    // (Only downstream is supported now...)
    for (Int_t ii=endlplatetopropagate; ii<=InBTplate; ++ii) {
 
        Float_t zpos=gAli->GetPattern(ii)->Z();
        if (gEDBDEBUGLEVEL>3) cout << "--- --- Loop: ii, zpos  "<< ii  <<  "  "  << zpos << "; Print InitiatorBT,ExtrapolateInitiatorBT"<<endl;
 
        ExtrapolateInitiatorBT->PropagateTo(zpos);
        if (gEDBDEBUGLEVEL>3) {
            InitiatorBT->PrintNice();
            ExtrapolateInitiatorBT->PrintNice();
        }
 
        mini[0]=ExtrapolateInitiatorBT->X()-halfsize;
        mini[1]=ExtrapolateInitiatorBT->Y()-halfsize;
        maxi[0]=ExtrapolateInitiatorBT->X()+halfsize;
        maxi[1]=ExtrapolateInitiatorBT->Y()+halfsize;
 
        singlePattern=(EdbPattern*)gAli->GetPattern(ii)->ExtractSubPattern(mini,maxi,InitiatorBT->MCEvt());
        singlePattern-> SetID(gAli->GetPattern(ii)->ID());
        singlePattern-> SetPID(gAli->GetPattern(ii)->PID());
        gAli_Sub->AddPattern(singlePattern);
    }
    if (gEDBDEBUGLEVEL>2) cout <<"--- gAli_Sub->Print():"<<endl;
    if (gEDBDEBUGLEVEL>2) gAli_Sub->Print();
    if (gEDBDEBUGLEVEL>2) cout <<"--- ----------------------------------"<<endl;
 
    return gAli_Sub;
}

Variable Documentation

cmd_ALI

Int_t cmd_ALI =0

cmd_ALTP

Int_t cmd_ALTP =2

cmd_BGTP

Int_t cmd_BGTP =0

cmd_BTPA

Int_t cmd_BTPA =0

cmd_CLEAN

Int_t cmd_CLEAN =0

cmd_CUTTP

Int_t cmd_CUTTP =0

cmd_EXTHETA

Int_t cmd_EXTHETA =0

cmd_FILETP

Int_t cmd_FILETP =0

cmd_FP

Int_t cmd_FP =1

cmd_FZHP

Int_t cmd_FZHP =0

cmd_GBMC

Int_t cmd_GBMC =0

cmd_gEDBDEBUGLEVEL

Int_t cmd_gEDBDEBUGLEVEL =2

cmd_lnkdef_name

char* cmd_lnkdef_name = "lnk.def"

cmd_LP

Int_t cmd_LP =30

cmd_LT

Int_t cmd_LT =0

cmd_MC

Int_t cmd_MC =0

cmd_MCFL

Int_t cmd_MCFL =0

cmd_MCMIX

Int_t cmd_MCMIX =0

cmd_MP

Int_t cmd_MP =1

cmd_NP

Int_t cmd_NP =30

cmd_OUTPUTLEVEL

Int_t cmd_OUTPUTLEVEL =1

cmd_PADI

Int_t cmd_PADI =0

cmd_PAEND

Int_t cmd_PAEND =0

cmd_PASTART

Int_t cmd_PASTART =0

cmd_STOPLEVEL

Int_t cmd_STOPLEVEL =0

cmd_vtx

Int_t cmd_vtx =0

CUT_PARAMETER

Double_t CUT_PARAMETER[10]

f_GSNN

TFile* f_GSNN

FILE_ParaSetDefinitions

TFile* FILE_ParaSetDefinitions

FILE_ShowRecEff

TFile* FILE_ShowRecEff

FILE_ShowRecHistos

TFile* FILE_ShowRecHistos

FILE_ShowShower

TFile* FILE_ShowShower

FILE_ShowTracks

TFile* FILE_ShowTracks

gEDBDEBUGLEVEL

Int_t gEDBDEBUGLEVEL =2

GLOBAL_effall

Double_t GLOBAL_effall

GLOBAL_effe

Double_t GLOBAL_effe

GLOBAL_EvtBT_E

Double_t GLOBAL_EvtBT_E

GLOBAL_EvtBT_EArray

Double_t GLOBAL_EvtBT_EArray[99999]

GLOBAL_EvtBT_Flag

Int_t GLOBAL_EvtBT_Flag

GLOBAL_EvtBT_FlagArray

Int_t GLOBAL_EvtBT_FlagArray[99999]

GLOBAL_EvtBT_MC

Int_t GLOBAL_EvtBT_MC

GLOBAL_EvtBT_MCArray

Int_t GLOBAL_EvtBT_MCArray[99999]

GLOBAL_EvtBT_TanTheta

Double_t GLOBAL_EvtBT_TanTheta

GLOBAL_EvtBT_TanThetaArray

Double_t GLOBAL_EvtBT_TanThetaArray[99999]

GLOBAL_EvtBT_ZArray

Int_t GLOBAL_EvtBT_ZArray[99999]

GLOBAL_gAli

EdbPVRec* GLOBAL_gAli

GLOBAL_InBT_E

Double_t GLOBAL_InBT_E

GLOBAL_InBT_Flag

Int_t GLOBAL_InBT_Flag

GLOBAL_InBT_MC

Int_t GLOBAL_InBT_MC

GLOBAL_InBT_TanTheta

Double_t GLOBAL_InBT_TanTheta

GLOBAL_InBTArray

TObjArray* GLOBAL_InBTArray

GLOBAL_InBTArrayEntries

Int_t GLOBAL_InBTArrayEntries

GLOBAL_INBTSHOWERNR

Int_t GLOBAL_INBTSHOWERNR

GLOBAL_IsBrickTreePGunInfo

Bool_t GLOBAL_IsBrickTreePGunInfo =kFALSE

GLOBAL_NBT

Int_t GLOBAL_NBT

GLOBAL_NBTallMC

Int_t GLOBAL_NBTallMC

GLOBAL_NBTeMC

Int_t GLOBAL_NBTeMC

GLOBAL_NBTMC

Int_t GLOBAL_NBTMC

GLOBAL_PARASETNR

Int_t GLOBAL_PARASETNR

GLOBAL_purall

Double_t GLOBAL_purall

GLOBAL_pure

Double_t GLOBAL_pure

GLOBAL_ShowerSegArray

TObjArray* GLOBAL_ShowerSegArray

GLOBAL_trckdens

Double_t GLOBAL_trckdens

GLOBAL_VtxArray

TObjArray* GLOBAL_VtxArray

GLOBAL_VtxArrayX

Float_t GLOBAL_VtxArrayX[99999]

GLOBAL_VtxArrayY

Float_t GLOBAL_VtxArrayY[99999]

GLOBAL_VtxArrayZ

Float_t GLOBAL_VtxArrayZ[99999]

h_GSNN_var00

TH1F* h_GSNN_var00

h_GSNN_var01

TH1F* h_GSNN_var01

h_GSNN_var02

TH1F* h_GSNN_var02

h_GSNN_var03

TH1F* h_GSNN_var03

h_GSNN_var04

TH1F* h_GSNN_var04

h_GSNN_var05

TH1F* h_GSNN_var05

h_GSNN_var06

TH1F* h_GSNN_var06

Hist2DimBGAndSimOneEventAllPlates

TH2F* Hist2DimBGAndSimOneEventAllPlates

Hist2DimBGAndSimOneEventOneGroupedPlate

TH2F* Hist2DimBGAndSimOneEventOneGroupedPlate[50]

Hist2DimOnlyBGAllPlates

TH2F* Hist2DimOnlyBGAllPlates

Hist2DimOnlyBGOneGroupedPlate

TH2F* Hist2DimOnlyBGOneGroupedPlate[50]

Hist2DimOnlySimOneEventAllPlates

TH2F* Hist2DimOnlySimOneEventAllPlates

Hist2DimOnlySimOneEventOneGroupedPlate

TH2F* Hist2DimOnlySimOneEventOneGroupedPlate[50]

Hist3DimOnlyBG

TH3F* Hist3DimOnlyBG

Hist3DimRecoEvent_gAli

TH3F* Hist3DimRecoEvent_gAli

Hist3DimRecoEvent_gAli_Dummy

TH3F* Hist3DimRecoEvent_gAli_Dummy

Hist_NBT_InBTE

TH2F* Hist_NBT_InBTE

Hist_NBTallMC_purall

TH2F* Hist_NBTallMC_purall

Hist_NBTeMC_InBTE

TH2F* Hist_NBTeMC_InBTE

Hist_NBTeMC_NBT

TH2F* Hist_NBTeMC_NBT

Hist_NBTeMC_NBTMC

TH2F* Hist_NBTeMC_NBTMC

Hist_NBTeMC_pure

TH2F* Hist_NBTeMC_pure

Hist_purall_InBTE

TH2F* Hist_purall_InBTE

Hist_pure_InBTE

TH2F* Hist_pure_InBTE

local_halfpatternsize

Float_t local_halfpatternsize =1250

NBT_InBTE

TProfile* NBT_InBTE

NBTallMC_purall

TProfile* NBTallMC_purall

NBTeMC_InBTE

TProfile* NBTeMC_InBTE

NBTeMC_NBT

TProfile* NBTeMC_NBT

NBTeMC_NBTMC

TProfile* NBTeMC_NBTMC

NBTeMC_pure

TProfile* NBTeMC_pure

purall_InBTE

TProfile* purall_InBTE

pure_InBTE

TProfile* pure_InBTE

shower_axis_txb

Float_t shower_axis_txb

shower_axis_tyb

Float_t shower_axis_tyb

shower_axis_xb

Float_t shower_axis_xb

shower_axis_yb

Float_t shower_axis_yb

shower_axis_zb

Float_t shower_axis_zb

shower_chi2btkb

Float_t shower_chi2btkb[5000]

shower_deltarb

Float_t shower_deltarb[5000]

shower_deltasigmathetab

Float_t shower_deltasigmathetab[58]

shower_deltathetab

Float_t shower_deltathetab[5000]

shower_deltaxb

Float_t shower_deltaxb[5000]

shower_deltayb

Float_t shower_deltayb[5000]

shower_energy_shot_particle

Float_t shower_energy_shot_particle

shower_filetype

Int_t shower_filetype

shower_idb

Int_t shower_idb[5000]

shower_isizeb

Int_t shower_isizeb

shower_nfilmb

Int_t shower_nfilmb[5000]

shower_ngrainb

Int_t shower_ngrainb[5000]

shower_ntrace1simub

Int_t shower_ntrace1simub[5000]

shower_ntrace2simub

Int_t shower_ntrace2simub[5000]

shower_ntrace3simub

Float_t shower_ntrace3simub[5000]

shower_ntrace4simub

Int_t shower_ntrace4simub[5000]

shower_number_eventb

Int_t shower_number_eventb

shower_numberofholes

Int_t shower_numberofholes =0

shower_numberofholesconseq

Int_t shower_numberofholesconseq =0

shower_numberofilms

Int_t shower_numberofilms

shower_plateb

Int_t shower_plateb[5000]

shower_purb

Float_t shower_purb

shower_showerID

Int_t shower_showerID

shower_sizeb

Int_t shower_sizeb

shower_sizeb15

Int_t shower_sizeb15

shower_sizeb20

Int_t shower_sizeb20

shower_sizeb30

Int_t shower_sizeb30

shower_tagprimary

Float_t shower_tagprimary[5000]

shower_trackdensb

Float_t shower_trackdensb

shower_txb

Float_t shower_txb[5000]

shower_tyb

Float_t shower_tyb[5000]

shower_xb

Float_t shower_xb[5000]

shower_yb

Float_t shower_yb[5000]

shower_zb

Float_t shower_zb[5000]

spectrum

TSpectrum2* spectrum[50]

spectrum2dim

TSpectrum2* spectrum2dim

spectrum_interim

TH2F* spectrum_interim

STREAM_ShowRecEff

ofstream STREAM_ShowRecEff

STREAM_ShowRecEffName

TString STREAM_ShowRecEffName

STREAM_ShowShower

ofstream STREAM_ShowShower

STRING_ShowShowerName

TString STRING_ShowShowerName

STRING_ShowTracksName

TString STRING_ShowTracksName

t_GSNN

TTree* t_GSNN

TMlpANN

TMultiLayerPerceptron* TMlpANN

TREE_ParaSetDefinitions

TTree* TREE_ParaSetDefinitions

TREE_ShowRecEff

TTree* TREE_ShowRecEff

TREE_ShowShower

TTree* TREE_ShowShower

value_GSNN_var00

Float_t value_GSNN_var00

value_GSNN_var01

Float_t value_GSNN_var01

value_GSNN_var02

Float_t value_GSNN_var02

value_GSNN_var03

Float_t value_GSNN_var03

value_GSNN_var04

Float_t value_GSNN_var04

value_GSNN_var05

Float_t value_GSNN_var05

value_GSNN_var06

Float_t value_GSNN_var06

value_GSNN_varInput

Float_t value_GSNN_varInput

var_NN__ALL__dR_InBT_To_TestBT

TH1F* var_NN__ALL__dR_InBT_To_TestBT

var_NN__ALL__dR_TestBT_To_InBT

TH1F* var_NN__ALL__dR_TestBT_To_InBT

var_NN__ALL__dT_InBT_To_TestBT

TH1F* var_NN__ALL__dT_InBT_To_TestBT

var_NN__ALL__mean_dR_TestBT_To2AfterPlate

TH1F* var_NN__ALL__mean_dR_TestBT_To2AfterPlate

var_NN__ALL__mean_dR_TestBT_To2BeforePlate

TH1F* var_NN__ALL__mean_dR_TestBT_To2BeforePlate

var_NN__ALL__mean_dR_TestBT_ToAfterPlate

TH1F* var_NN__ALL__mean_dR_TestBT_ToAfterPlate

var_NN__ALL__mean_dR_TestBT_ToBeforePlate

TH1F* var_NN__ALL__mean_dR_TestBT_ToBeforePlate

var_NN__ALL__mean_dR_TestBT_ToSamePlate

TH1F* var_NN__ALL__mean_dR_TestBT_ToSamePlate

var_NN__ALL__mean_dT_TestBT_To2AfterPlate

TH1F* var_NN__ALL__mean_dT_TestBT_To2AfterPlate

var_NN__ALL__mean_dT_TestBT_To2BeforePlate

TH1F* var_NN__ALL__mean_dT_TestBT_To2BeforePlate

var_NN__ALL__mean_dT_TestBT_ToAfterPlate

TH1F* var_NN__ALL__mean_dT_TestBT_ToAfterPlate

var_NN__ALL__mean_dT_TestBT_ToBeforePlate

TH1F* var_NN__ALL__mean_dT_TestBT_ToBeforePlate

var_NN__ALL__mean_dT_TestBT_ToSamePlate

TH1F* var_NN__ALL__mean_dT_TestBT_ToSamePlate

var_NN__ALL__min_dR_TestBT_To2AfterPlate

TH1F* var_NN__ALL__min_dR_TestBT_To2AfterPlate

var_NN__ALL__min_dR_TestBT_To2BeforePlate

TH1F* var_NN__ALL__min_dR_TestBT_To2BeforePlate

var_NN__ALL__min_dR_TestBT_ToAfterPlate

TH1F* var_NN__ALL__min_dR_TestBT_ToAfterPlate

var_NN__ALL__min_dR_TestBT_ToBeforePlate

TH1F* var_NN__ALL__min_dR_TestBT_ToBeforePlate

var_NN__ALL__min_dR_TestBT_ToSamePlate

TH1F* var_NN__ALL__min_dR_TestBT_ToSamePlate

var_NN__ALL__min_dT_TestBT_To2AfterPlate

TH1F* var_NN__ALL__min_dT_TestBT_To2AfterPlate

var_NN__ALL__min_dT_TestBT_To2BeforePlate

TH1F* var_NN__ALL__min_dT_TestBT_To2BeforePlate

var_NN__ALL__min_dT_TestBT_ToAfterPlate

TH1F* var_NN__ALL__min_dT_TestBT_ToAfterPlate

var_NN__ALL__min_dT_TestBT_ToBeforePlate

TH1F* var_NN__ALL__min_dT_TestBT_ToBeforePlate

var_NN__ALL__min_dT_TestBT_ToSamePlate

TH1F* var_NN__ALL__min_dT_TestBT_ToSamePlate

var_NN__ALL__nseg_TestBT_To2AfterPlate

TH1F* var_NN__ALL__nseg_TestBT_To2AfterPlate

var_NN__ALL__nseg_TestBT_To2BeforePlate

TH1F* var_NN__ALL__nseg_TestBT_To2BeforePlate

var_NN__ALL__nseg_TestBT_ToAfterPlate

TH1F* var_NN__ALL__nseg_TestBT_ToAfterPlate

var_NN__ALL__nseg_TestBT_ToBeforePlate

TH1F* var_NN__ALL__nseg_TestBT_ToBeforePlate

var_NN__ALL__nseg_TestBT_ToSamePlate

TH1F* var_NN__ALL__nseg_TestBT_ToSamePlate

var_NN__ALL__SpatialDist_TestBT_To_InBT

TH1F* var_NN__ALL__SpatialDist_TestBT_To_InBT

var_NN__ALL__zDiff_TestBT_To_InBT

TH1F* var_NN__ALL__zDiff_TestBT_To_InBT

var_NN__BG__dR_InBT_To_TestBT

TH1F* var_NN__BG__dR_InBT_To_TestBT

var_NN__BG__dR_TestBT_To_InBT

TH1F* var_NN__BG__dR_TestBT_To_InBT

var_NN__BG__dT_InBT_To_TestBT

TH1F* var_NN__BG__dT_InBT_To_TestBT

var_NN__BG__mean_dR_TestBT_To2AfterPlate

TH1F* var_NN__BG__mean_dR_TestBT_To2AfterPlate

var_NN__BG__mean_dR_TestBT_To2BeforePlate

TH1F* var_NN__BG__mean_dR_TestBT_To2BeforePlate

var_NN__BG__mean_dR_TestBT_ToAfterPlate

TH1F* var_NN__BG__mean_dR_TestBT_ToAfterPlate

var_NN__BG__mean_dR_TestBT_ToBeforePlate

TH1F* var_NN__BG__mean_dR_TestBT_ToBeforePlate

var_NN__BG__mean_dR_TestBT_ToSamePlate

TH1F* var_NN__BG__mean_dR_TestBT_ToSamePlate

var_NN__BG__mean_dT_TestBT_To2AfterPlate

TH1F* var_NN__BG__mean_dT_TestBT_To2AfterPlate

var_NN__BG__mean_dT_TestBT_To2BeforePlate

TH1F* var_NN__BG__mean_dT_TestBT_To2BeforePlate

var_NN__BG__mean_dT_TestBT_ToAfterPlate

TH1F* var_NN__BG__mean_dT_TestBT_ToAfterPlate

var_NN__BG__mean_dT_TestBT_ToBeforePlate

TH1F* var_NN__BG__mean_dT_TestBT_ToBeforePlate

var_NN__BG__mean_dT_TestBT_ToSamePlate

TH1F* var_NN__BG__mean_dT_TestBT_ToSamePlate

var_NN__BG__min_dR_TestBT_To2AfterPlate

TH1F* var_NN__BG__min_dR_TestBT_To2AfterPlate

var_NN__BG__min_dR_TestBT_To2BeforePlate

TH1F* var_NN__BG__min_dR_TestBT_To2BeforePlate

var_NN__BG__min_dR_TestBT_ToAfterPlate

TH1F* var_NN__BG__min_dR_TestBT_ToAfterPlate

var_NN__BG__min_dR_TestBT_ToBeforePlate

TH1F* var_NN__BG__min_dR_TestBT_ToBeforePlate

var_NN__BG__min_dR_TestBT_ToSamePlate

TH1F* var_NN__BG__min_dR_TestBT_ToSamePlate

var_NN__BG__min_dT_TestBT_To2AfterPlate

TH1F* var_NN__BG__min_dT_TestBT_To2AfterPlate

var_NN__BG__min_dT_TestBT_To2BeforePlate

TH1F* var_NN__BG__min_dT_TestBT_To2BeforePlate

var_NN__BG__min_dT_TestBT_ToAfterPlate

TH1F* var_NN__BG__min_dT_TestBT_ToAfterPlate

var_NN__BG__min_dT_TestBT_ToBeforePlate

TH1F* var_NN__BG__min_dT_TestBT_ToBeforePlate

var_NN__BG__min_dT_TestBT_ToSamePlate

TH1F* var_NN__BG__min_dT_TestBT_ToSamePlate

var_NN__BG__nseg_TestBT_To2AfterPlate

TH1F* var_NN__BG__nseg_TestBT_To2AfterPlate

var_NN__BG__nseg_TestBT_To2BeforePlate

TH1F* var_NN__BG__nseg_TestBT_To2BeforePlate

var_NN__BG__nseg_TestBT_ToAfterPlate

TH1F* var_NN__BG__nseg_TestBT_ToAfterPlate

var_NN__BG__nseg_TestBT_ToBeforePlate

TH1F* var_NN__BG__nseg_TestBT_ToBeforePlate

var_NN__BG__nseg_TestBT_ToSamePlate

TH1F* var_NN__BG__nseg_TestBT_ToSamePlate

var_NN__BG__SpatialDist_TestBT_To_InBT

TH1F* var_NN__BG__SpatialDist_TestBT_To_InBT

var_NN__BG__zDiff_TestBT_To_InBT

TH1F* var_NN__BG__zDiff_TestBT_To_InBT

var_NN__SG__dR_InBT_To_TestBT

TH1F* var_NN__SG__dR_InBT_To_TestBT

var_NN__SG__dR_TestBT_To_InBT

TH1F* var_NN__SG__dR_TestBT_To_InBT

var_NN__SG__dT_InBT_To_TestBT

TH1F* var_NN__SG__dT_InBT_To_TestBT

var_NN__SG__mean_dR_TestBT_To2AfterPlate

TH1F* var_NN__SG__mean_dR_TestBT_To2AfterPlate

var_NN__SG__mean_dR_TestBT_To2BeforePlate

TH1F* var_NN__SG__mean_dR_TestBT_To2BeforePlate

var_NN__SG__mean_dR_TestBT_ToAfterPlate

TH1F* var_NN__SG__mean_dR_TestBT_ToAfterPlate

var_NN__SG__mean_dR_TestBT_ToBeforePlate

TH1F* var_NN__SG__mean_dR_TestBT_ToBeforePlate

var_NN__SG__mean_dR_TestBT_ToSamePlate

TH1F* var_NN__SG__mean_dR_TestBT_ToSamePlate

var_NN__SG__mean_dT_TestBT_To2AfterPlate

TH1F* var_NN__SG__mean_dT_TestBT_To2AfterPlate

var_NN__SG__mean_dT_TestBT_To2BeforePlate

TH1F* var_NN__SG__mean_dT_TestBT_To2BeforePlate

var_NN__SG__mean_dT_TestBT_ToAfterPlate

TH1F* var_NN__SG__mean_dT_TestBT_ToAfterPlate

var_NN__SG__mean_dT_TestBT_ToBeforePlate

TH1F* var_NN__SG__mean_dT_TestBT_ToBeforePlate

var_NN__SG__mean_dT_TestBT_ToSamePlate

TH1F* var_NN__SG__mean_dT_TestBT_ToSamePlate

var_NN__SG__min_dR_TestBT_To2AfterPlate

TH1F* var_NN__SG__min_dR_TestBT_To2AfterPlate

var_NN__SG__min_dR_TestBT_To2BeforePlate

TH1F* var_NN__SG__min_dR_TestBT_To2BeforePlate

var_NN__SG__min_dR_TestBT_ToAfterPlate

TH1F* var_NN__SG__min_dR_TestBT_ToAfterPlate

var_NN__SG__min_dR_TestBT_ToBeforePlate

TH1F* var_NN__SG__min_dR_TestBT_ToBeforePlate

var_NN__SG__min_dR_TestBT_ToSamePlate

TH1F* var_NN__SG__min_dR_TestBT_ToSamePlate

var_NN__SG__min_dT_TestBT_To2AfterPlate

TH1F* var_NN__SG__min_dT_TestBT_To2AfterPlate

var_NN__SG__min_dT_TestBT_To2BeforePlate

TH1F* var_NN__SG__min_dT_TestBT_To2BeforePlate

var_NN__SG__min_dT_TestBT_ToAfterPlate

TH1F* var_NN__SG__min_dT_TestBT_ToAfterPlate

var_NN__SG__min_dT_TestBT_ToBeforePlate

TH1F* var_NN__SG__min_dT_TestBT_ToBeforePlate

var_NN__SG__min_dT_TestBT_ToSamePlate

TH1F* var_NN__SG__min_dT_TestBT_ToSamePlate

var_NN__SG__nseg_TestBT_To2AfterPlate

TH1F* var_NN__SG__nseg_TestBT_To2AfterPlate

var_NN__SG__nseg_TestBT_To2BeforePlate

TH1F* var_NN__SG__nseg_TestBT_To2BeforePlate

var_NN__SG__nseg_TestBT_ToAfterPlate

TH1F* var_NN__SG__nseg_TestBT_ToAfterPlate

var_NN__SG__nseg_TestBT_ToBeforePlate

TH1F* var_NN__SG__nseg_TestBT_ToBeforePlate

var_NN__SG__nseg_TestBT_ToSamePlate

TH1F* var_NN__SG__nseg_TestBT_ToSamePlate

var_NN__SG__SpatialDist_TestBT_To_InBT

TH1F* var_NN__SG__SpatialDist_TestBT_To_InBT

var_NN__SG__zDiff_TestBT_To_InBT

TH1F* var_NN__SG__zDiff_TestBT_To_InBT

var_NN_DoRUN

Bool_t var_NN_DoRUN =kTRUE

var_NN_DoTrain

Bool_t var_NN_DoTrain =kFALSE