// for 4.11.1

#include "TTree.h"
#include "TBranch.h"
#include "TLeaf.h"
#include "UCNtuple/myuber_t.hh"

void declarestructs(TTree* tree, myuber_t * uber) {
  TObjArray* leaveslist;
  Int_t * pointer;

  TBranch* headerBranch = tree->GetBranch("header");
  if (headerBranch)
    headerBranch->SetAddress(&(uber->header));

  TBranch* triggerBranch = tree->GetBranch("trigger");
  if (triggerBranch) {
    triggerBranch->SetAddress(&(uber->trigger));
    triggerBranch->GetLeaf("nl1trigs")->SetAddress(&(uber->trigger.nl1trigs));
    triggerBranch->GetLeaf("l1trigs")->SetAddress(uber->trigger.l1trigs);
    triggerBranch->GetLeaf("nl2trigs")->SetAddress(&(uber->trigger.nl2trigs));
    triggerBranch->GetLeaf("l2trigs")->SetAddress(uber->trigger.l2trigs);
    triggerBranch->GetLeaf("nl3trigs")->SetAddress(&(uber->trigger.nl3trigs));
    triggerBranch->GetLeaf("l3trigs")->SetAddress(uber->trigger.l3trigs);
  }

  TBranch* vertexBranch = tree->GetBranch("vertex");
  if (vertexBranch) {
    vertexBranch->SetAddress(&(uber->vertex));
    leaveslist = vertexBranch->GetListOfLeaves();
    pointer = (Int_t *) uber->vertex.x;
    for (int i = 2; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      pointer += MAXPVERT;
    }
  }

  TBranch* metBranch = tree->GetBranch("met");
  if (metBranch)
    metBranch->SetAddress(&(uber->met));

  TBranch* photonBranch = tree->GetBranch("photon");
  if (photonBranch) {
    //    tree->SetBranchAddress("photon", &(uber->photon));
    photonBranch->SetAddress(&(uber->photon));
    photonBranch = tree->GetBranch("photon");
    leaveslist = photonBranch->GetListOfLeaves();
    pointer = (uber->photon).detector;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (tl->GetLeafCount()) {
        pointer += MAXPHO;
      } else {
        pointer++;
      }
    }
  }

  TBranch* jetBranch = tree->GetBranch("jet");
  if (jetBranch) {
    jetBranch->SetAddress(&(uber->jet));
    leaveslist = jetBranch->GetListOfLeaves();
    pointer = (uber->jet).ntrks;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (tl->GetLeafCount()) {
	if (strstr(tl->GetTitle(), "[3]")) {
	  pointer += MAXJET*3;
	} else {
	  pointer += MAXJET;
	}
      } else {
        pointer++;
      }
    }
  }

  TBranch* jet2Branch = tree->GetBranch("jet2");
  if (jet2Branch) {
    jet2Branch->SetAddress(&(uber->jet2));
    leaveslist = jet2Branch->GetListOfLeaves();
    pointer = (uber->jet2).ntrks;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (tl->GetLeafCount()) {
	if (strstr(tl->GetTitle(), "[3]")) {
	  pointer += MAXJET*3;
	} else {
	  pointer += MAXJET;
	}
      } else {
        pointer++;
      }
    }
  }   

  TBranch* jet3Branch = tree->GetBranch("jet3");
  if (jet3Branch) {
    jet3Branch->SetAddress(&(uber->jet3));
    leaveslist = jet3Branch->GetListOfLeaves();
    pointer = (uber->jet3).ntrks;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (tl->GetLeafCount()) {
        if (strstr(tl->GetTitle(), "[3]")) {
          pointer += MAXJET*3;
        } else {
          pointer += MAXJET;
        }
      } else {
        pointer++;
      }
    }
  }
  
  TBranch* eleBranch = tree->GetBranch("ele");
  if (eleBranch) {
    eleBranch->SetAddress(&(uber->electron));
    leaveslist = eleBranch->GetListOfLeaves();
    pointer = (uber->electron).clustersize;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      pointer += MAXELE;
    }
  }
  
  TBranch* muonBranch = tree->GetBranch("muon");
  if (muonBranch) {
    muonBranch->SetAddress(&(uber->muon));
    leaveslist = muonBranch->GetListOfLeaves();
    pointer = (uber->muon).fid;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (tl->GetLeafCount()) {
	pointer += MAXMUO;
      } else {
	pointer++;
      }
    }
  }

  TBranch* tauBranch = tree->GetBranch("tau");
  if (tauBranch) {
    tauBranch->SetAddress(&(uber->tau));
    leaveslist = tauBranch->GetListOfLeaves();
    pointer = (uber->tau).ntowers;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      pointer += MAXTAU;
    }
  }

  TBranch* trackBranch = tree->GetBranch("track");
  if (trackBranch) {
    trackBranch->SetAddress(&(uber->track));
    leaveslist = trackBranch->GetListOfLeaves();
    pointer = (uber->track).naxialsl;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (strstr(tl->GetTitle(), "[5]")) {
	pointer += MAXTRACKS*5;
      } else {
	pointer += MAXTRACKS;
      }
    }
  }

  TBranch* topBranch = tree->GetBranch("top");
  if (topBranch) {
    topBranch->SetAddress(&(uber->top));
    leaveslist = topBranch->GetListOfLeaves();
    pointer = (Int_t*) (uber->top).teleindex;
    for (int i = 26; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (i == 27 || i == 28)
        pointer += MAXELE;
      else if (i == 29 || i == 30)
        pointer += MAXMUO;
    }
  }

  TBranch* taggingBranch = tree->GetBranch("tagging");
  if (taggingBranch) {
    taggingBranch->SetAddress(&(uber->tagging));
    leaveslist = taggingBranch->GetListOfLeaves();
    pointer = (Int_t*) (uber->tagging).pvxyz;
    for (int i = 4; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (strstr(tl->GetTitle(), "[6]")) {
	pointer += 6;
      } else if (strstr(tl->GetTitle(), "[nsecvtx]")) {
	if (strstr(tl->GetTitle(), "[3]")) {
	  pointer += MAXSECVTX*3;
	} else {
	  pointer += MAXSECVTX;
	}
      } else if (strstr(tl->GetTitle(), "[nsvtrk]")) {
	pointer += MAXSECVTXTRK;
      }
    }
  }
  
  TBranch* obspBranch = tree->GetBranch("obsp");
  if (obspBranch) {
    obspBranch->SetAddress(&(uber->obsp));
    leaveslist = obspBranch->GetListOfLeaves();
    pointer = (uber->obsp).number;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      pointer += MAXOBSP;
    }
  }

  TBranch* obsvBranch = tree->GetBranch("obsv");
  if (obsvBranch) {
    obsvBranch->SetAddress(&(uber->obsv));
    leaveslist = obsvBranch->GetListOfLeaves();
    pointer = (uber->obsv).number;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      pointer += MAXOBSV;
    }
  }

  TBranch* hepgBranch = tree->GetBranch("hepg");
  if (hepgBranch) {
    hepgBranch->SetAddress(&(uber->hepg));
    leaveslist = hepgBranch->GetListOfLeaves();
    pointer = (uber->hepg).pdg;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (strstr(tl->GetName(), "Mother")
	  || strstr(tl->GetName(), "Daughter")) {
	pointer += MAXHEPG*2;
      } else {
	pointer += MAXHEPG;
      }
    }
  }

  TBranch* svtBranch = tree->GetBranch("svt");
  if (svtBranch) {
    svtBranch->SetAddress(&(uber->svt));
    leaveslist = svtBranch->GetListOfLeaves();
    pointer = &((uber->svt).nsvt);
    for (int i = 0; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      pointer += MAXSVT;
    }
  }

  TBranch* xtrpBranch = tree->GetBranch("xtrp");
  if (xtrpBranch) {
    xtrpBranch->SetAddress(&(uber->xtrp));
    leaveslist = xtrpBranch->GetListOfLeaves();
    pointer = (uber->xtrp).fid;
    for (int i = 1; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      pointer += MAXXTRP;
    }
  }

  TBranch* zbbBranch = tree->GetBranch("zbb");
  if (zbbBranch) {
    zbbBranch->SetAddress(&(uber->zbb));
    leaveslist = zbbBranch->GetListOfLeaves();
    pointer = &((uber->zbb).hepgZ);
    for (int i = 0; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (tl->GetLeafCount()) {
	if (strstr(tl->GetName(), "[2]")) {
	  pointer += 2;
	} else if (strstr(tl->GetName(), "[ngele]")) {
	  pointer += MAXGELE;
	} else if (strstr(tl->GetName(), "[ngmuo]")) {
	  pointer += MAXGMUO;
	} else if (strstr(tl->GetName(), "[ngneu]")) {
	  pointer += MAXGNEU;
	}
      } else {
	pointer++;
      }
    }
  }

  TBranch* caltrigBranch = tree->GetBranch("CalTrigger");
  if (caltrigBranch) {
    caltrigBranch->SetAddress(&(uber->caltrigger));
    leaveslist = caltrigBranch->GetListOfLeaves();
    pointer = &((uber->caltrigger).ntower);
    for (int i = 0; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (tl->GetLeafCount()) {
	if (strstr(tl->GetName(), "[ntower]")) {
	  pointer += MAXTRTW;
	} else if (strstr(tl->GetName(), "[ncluster]")) {
	  pointer += MAXCLST;
	}
      } else {
	pointer++;
      }
    }
  }

  TBranch* l3Branch = tree->GetBranch("Level3");
  if (l3Branch) {
    l3Branch->SetAddress(&(uber->level3));
    leaveslist = l3Branch->GetListOfLeaves();
    pointer = &((uber->level3).ntrkCot2Svt);
    for (int i = 0; i < leaveslist->GetEntries(); i++) {
      TLeaf * tl = (TLeaf*) (*leaveslist)[i];
      tl->SetAddress(pointer);
      if (tl->GetLeafCount()) {
	if (strstr(tl->GetName(), "[ntrkCot2Svt]")) {
	  pointer += MAXL3TK;
	} else if (strstr(tl->GetName(), "[nPerm]")) {
	  pointer += MAXPERM;
	} else if (strstr(tl->GetName(), "[nJet07]")
		   || strstr(tl->GetName(), "[nJet04]")) {
	  pointer += MAXL3JT;
	} 
      } else {
	pointer++;
      }
    }
  }

}