diff --git a/.gitignore b/.gitignore
index faaef28c56ad8060f6ad56b95b51a2014cac8e80..35bedde16a9af093da8fb1506cdfad682e5be2ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 anaroot/
 build/
 rootfiles/
+figure/
 *.ridf
 *.root
diff --git a/doc/mapfile.md b/doc/mapfile.md
index a46f87d61ba557d927cff9a368a4a128351ffddb..3a8266fc333d4ed4a506d7653be6461493c1be6a 100644
--- a/doc/mapfile.md
+++ b/doc/mapfile.md
@@ -1,2 +1,8 @@
 # mapfile setting
 these mapfile was created for the ANAPAW. I copied from ANAPAW source.
+
+## raw data
+detector id is set to:
+* 6: ADC
+* 7: TDC
+* 10: multi hit TDC
diff --git a/include/ChannelMap.hh b/include/MapReader.hh
similarity index 59%
rename from include/ChannelMap.hh
rename to include/MapReader.hh
index 8e7e701e48234b56a11b9bff767fb165e6252c78..05c476170aa6b6351467c99dd696f1521bb5e541 100644
--- a/include/ChannelMap.hh
+++ b/include/MapReader.hh
@@ -1,27 +1,34 @@
-#ifndef _CHANNELMAP_HH_
-#define _CHANNELMAP_HH_
+#ifndef _MapReader_HH_
+#define _MapReader_HH_
 
 #include <iostream>
 #include <fstream>
 #include <string>
 
-#include <TTree.h>
+#include <TSystem.h>
 
 using namespace std;
 
 
-class ChannelMap
+class MapReader
 {
   private:
     TString filename;
 
   public:
-    ChannelMap(){}
-    ChannelMap(TString in_filename){
+    MapReader(){}
+    MapReader(TString in_filename){
       filename = in_filename;
+
+      FileStat_t info;
+      if(gSystem->GetPathInfo(filename.Data(), info) != 0){
+        cerr << "EROOR: in yaml File, '" << filename.Data() << "' does not exist." << endl;
+        exit(0);
+      }
+
       ReadMap();
     }
-    ~ChannelMap(){}
+    ~MapReader(){}
 
     Int_t size = 0;
     vector< vector<Int_t> > segment_id;
diff --git a/include/TCordferBranchManager.hh b/include/TCordferBranchManager.hh
index 39af4da3dfd4e674f77f245567040c4338509542..2630a79b239386a5a38735cbba48a619506251d6 100644
--- a/include/TCordferBranchManager.hh
+++ b/include/TCordferBranchManager.hh
@@ -10,7 +10,7 @@
 #include <TTree.h>
 #include <TH1.h>
 
-#include "ChannelMap.hh"
+#include "MapReader.hh"
 #include "CalibParamReader.hh"
 #include "TCordferRawBranch.hh"
 #include "TCordferMapBranch.hh"
@@ -34,16 +34,19 @@ class TCordferBranchManager
     vector<TCordferRawBranch*> branch;
     vector<TCordferMapBranch*> mbranch;
     vector<TCordferCalibBranch*> cbranch;
-    unordered_map<Int_t, Int_t> mapping;
-    unordered_map<Int_t, Int_t> mmapping;
-    unordered_map<Int_t, Int_t> cmapping;
-    unordered_map<Int_t, Int_t> muxmapping;
+    Int_t rmapping[100]; //segment_id(geo) -> branch index
+    Int_t mmapping[100][100]; // [segment_id][ch] -> branch index
+    Int_t cmapping[100][100];
+    Int_t muxmapping[100][100];
 
-    vector< vector<Double_t> > mpos; //for mssd
+    vector< vector<Double_t> > mpos; //for position parameter of MUX (mssd)
+
+    bool rawdata = false;
+    bool mapdata = false;
+    bool calibration = false;
 
-    //for temporary
     bool rmapflag = false;
-    bool mapflag = false;
+    bool mmapflag = false;
     bool cmapflag = false;
 
   public:
@@ -59,28 +62,50 @@ class TCordferBranchManager
 
     void Readyaml(TString yamlfile);
     void CreateRootFile(){ rootfile = new TFile(root_name.Data(), "recreate"); }
+
+    void CreateTree();
     void CreateRawTree();
     void CreateMapTree();
     void CreateCalibTree();
+
+    void CreateBranch();
     void CreateRawBranch();
     void CreateMapBranch();
     void CreateCalibBranch();
-    void CreateRawMapping();
+    Int_t MakeBranchChannelIndex(Int_t bra_id, Int_t ch_id){
+      return bra_id*100 + ch_id;
+    }
+    array<Int_t, 2> GetBranchChannelIndex(Int_t index){
+      Int_t j = index % 100;
+      Int_t i = (index - j)/100;
+      return {i, j};
+    }
+
     void CreateMapping();
+    void CreateRawMapping();
+    void CreateMapMapping();
     void CreateCalibMapping();
+
+    void GiveValue(Int_t geo, Int_t ch, Int_t val);
     void GiveRawValue(Int_t geo, Int_t ch, Int_t val);
     void GiveMapValue(Int_t geo, Int_t ch, Int_t val);
     void GiveCalibValue(Int_t geo, Int_t ch, Int_t val);
-    void GiveWaitCalibValue();
+
+    void Fill();
     void RawFill(){ tree->Fill(); }
     void MapFill(){ mtree->Fill(); }
     void CalibFill() { ctree->Fill(); }
+
+    void ClearAll();
     void ClearRawAll();
     void ClearMapAll();
     void ClearCalibAll();
+
+    void DataWrite();
     void RawDataWrite(){ tree->Write(); }
-    void DataWrite(){ mtree->Write(); }
+    void MapDataWrite(){ mtree->Write(); }
     void CalibDataWrite(){ ctree->Write(); }
+
     void FileClose();
 
     void DEBUG_PRINT();
diff --git a/include/TCordferCalibBranch.hh b/include/TCordferCalibBranch.hh
index 23f34557d0ce64618484eec15e204f5e835ebeb4..a471ce791d0cb7e1f3227564e2aefd5874a205a8 100644
--- a/include/TCordferCalibBranch.hh
+++ b/include/TCordferCalibBranch.hh
@@ -3,6 +3,7 @@
 
 #include <iostream>
 #include <vector>
+#include <array>
 
 #include <TSystem.h>
 
@@ -15,12 +16,14 @@ class TCordferCalibBranch
 
   public:
     TCordferCalibBranch(){}
-    TCordferCalibBranch(TString bname){
+    TCordferCalibBranch(TString bname, Int_t det_id){
       name = bname;
+      detector_id = det_id;
     }
     ~TCordferCalibBranch(){}
 
     bool adc;
+    Int_t detector_id;
     Int_t geo;
     Int_t ch;
     Int_t calib_dim;
@@ -36,31 +39,24 @@ class TCordferCalibBranch
     bool mux_pos2;
     bool mux1_junk;
     bool mux2_junk;
-    Int_t mux_ch1;
-    Int_t mux_ch2;
-    Int_t geo_tmp1;
-    Int_t geo_tmp2;
-    Int_t ch_tmp1;
-    Int_t ch_tmp2;
     Int_t val_tmp1;
     Int_t val_tmp2;
+    Int_t pval_tmp1;
+    Int_t pval_tmp2;
     vector<Double_t> mpos1_prm;
     vector<Double_t> mpos2_prm;
 
     TString GetBranchName(){ return name; }
 
-    void SetGeometrytmp1(Int_t geo, Int_t ch, Int_t val){
-      geo_tmp1 = geo;
-      ch_tmp1 = ch;
-      val_tmp1 = val;
-    }
-    void SetGeometrytmp2(Int_t geo, Int_t ch, Int_t val){
-      geo_tmp2 = geo;
-      ch_tmp2 = ch;
-      val_tmp2 = val;
-    }
-
     void CopyCalibInfo(Int_t dim, vector<Double_t> param);
+
+    Int_t GetCalibStatus(Int_t val, Int_t mux_id);
+    Int_t GetAddBranchIndex(Int_t mux_id);
+    void SetCalibValue(Int_t val);
+
+    Double_t GetCalibValue(Int_t val, vector<Double_t> params);
+
+    void Clear();
 };
 
 #endif
diff --git a/include/TCordferMapBranch.hh b/include/TCordferMapBranch.hh
index 33475b99b6d0ed17469cb3da00f1964228e5b3cf..732417c00d1c110a10395a1c4539173929af7820 100644
--- a/include/TCordferMapBranch.hh
+++ b/include/TCordferMapBranch.hh
@@ -15,23 +15,28 @@ class TCordferMapBranch
 
   public:
     TCordferMapBranch(){}
-    TCordferMapBranch(TString bname, Int_t bsize){
+    TCordferMapBranch(TString bname, Int_t det_id, Int_t bsize){
       name = bname;
+      detector_id = det_id;
       size = bsize;
+      MemorySet();
     }
     ~TCordferMapBranch(){}
 
     bool adc;
-    Int_t size; //use
-    Int_t *bra_val; //use
-    vector<Int_t> segment_id; //use
-    vector<Int_t> channel; //use
+    Int_t detector_id;
+    Int_t size;
+    Int_t *bra_val;
+    vector<Int_t> segment_id;
+    vector<Int_t> channel;
 
     TString GetBranchName(){ return name; }
 
     void MemorySet(){ bra_val = new Int_t[size]; }
     void FreeMemory(){ delete[] bra_val; }
-    void CopyMapInfo(vector<Int_t> seg, vector<Int_t> ch);
+    void SetMapInfo(vector<Int_t> seg, vector<Int_t> ch);
+
+    void Clear();
 };
 
 #endif
diff --git a/include/TCordferRawBranch.hh b/include/TCordferRawBranch.hh
index b8472b8b3b6d15195d362500302702c353acb305..a1a3db5d4eb6803324cd4f4fbf12f5e5c9ca64e4 100644
--- a/include/TCordferRawBranch.hh
+++ b/include/TCordferRawBranch.hh
@@ -15,18 +15,25 @@ class TCordferRawBranch
 
   public:
     TCordferRawBranch(){}
-    TCordferRawBranch(TString bname, Int_t bsize){
+    TCordferRawBranch(TString bname, Int_t segment_id, Int_t bsize, Int_t det_id){
       name = bname;
+      geo = segment_id;
       size = bsize;
+      detector_id = det_id;
+      MemorySet();
     }
-    TCordferRawBranch(TString bname, Int_t bsize, Int_t bnhit){
+    TCordferRawBranch(TString bname, Int_t segment_id, Int_t bsize, Int_t det_id, Int_t bnhit){
       name = bname;
+      geo = segment_id;
       size = bsize;
+      detector_id = det_id;
       nhit = bnhit;
+      TwoDimMemorySet();
     }
     ~TCordferRawBranch(){}
 
     Int_t size;
+    Int_t detector_id;
     Int_t nhit;
     Int_t geo;
     Int_t *bra_val;
@@ -40,6 +47,10 @@ class TCordferRawBranch
     void TwoDimMemorySet();
     void FreeMemory(){ delete[] bra_val; }
     void FreeTwoDimMemory();
+
+    //bool SetValue(Int_t ch, Int_t val); //return flag of mhtdc of others
+    void Clear();
+    void FreeAll();
 };
 
 #endif
diff --git a/macro/mpos_2dim.C b/macro/mpos_2dim.C
new file mode 100644
index 0000000000000000000000000000000000000000..e35039a9c5730353c104dfdb165ad03ee10d06d6
--- /dev/null
+++ b/macro/mpos_2dim.C
@@ -0,0 +1,31 @@
+// ********FOR Si26a**************
+//
+// --RUN INFORMATION
+// run307 alpha calibration Tel1-3 dE1&2, Tel4-5 dE2
+// run308 the same condition
+//
+// --MUX INFORMATION
+// driver for MUX2-1 is missing -> use MUX3-1
+//
+// --CHANNEL INFORMATION OF MUX
+// madc2[0]-[3]  : MUX1-1
+// madc2[4]-[7]  : MUX1-2
+// madc2[8]-[11] : MUX2-1
+// madc2[12]-[15]: MUX2-2
+// madc2[16]-[19]: MUX3-1
+// madc2[20]-[23]: MUX3-2
+
+{
+  gStyle->SetOptLogz(1);
+
+  TFile *fin = new TFile("../rootfiles/old_rootfiles/alpha307_308.root", "read");
+  TTree *tree = (TTree*)fin->Get("tree");
+
+  TCanvas *c1 = new TCanvas("c1","c1");
+  //tree->Draw("madc2[23]:madc2[21]>>(100, 0, 2000, 100, 1550, 1950)","","colz");
+  //tree->Draw("madc2[3]:madc2[2]>>(175, 350, 700, 175, 350, 750)","","colz");
+  tree->Draw("madc2[3]:madc2[2]>>(175, 350, 750, 400, 0, 800)","","colz");
+  //tree->Draw("madc2[21]>>(100, 0, 2000)");
+
+  //c1->Print("../figure/twodim_mpos2.png");
+}
diff --git a/macro/raw_mpos_check.C b/macro/raw_mpos_check.C
new file mode 100644
index 0000000000000000000000000000000000000000..f5e19e598425bf626791abefc52e767a57098899
--- /dev/null
+++ b/macro/raw_mpos_check.C
@@ -0,0 +1,91 @@
+// ********FOR Si26a**************
+//
+// --RUN INFORMATION
+// run307 alpha calibration Tel1-3 dE1&2, Tel4-5 dE2
+// run308 the same condition
+//
+// --MUX INFORMATION
+// driver for MUX2-1 is missing -> use MUX3-1
+//
+// --CHANNEL INFORMATION OF MUX
+// madc2[0]-[3]  : MUX1-1
+// madc2[4]-[7]  : MUX1-2
+// madc2[8]-[11] : MUX2-1
+// madc2[12]-[15]: MUX2-2
+// madc2[16]-[19]: MUX3-1
+// madc2[20]-[23]: MUX3-2
+
+{
+  gStyle->SetOptLogy(1);
+
+  //for run307 and 308
+  TFile *fin = new TFile("../rootfiles/old_rootfiles/alpha307_308.root", "read");
+  TTree *tree = (TTree*)fin->Get("tree");
+  //TChain *chain = new TChain("tree", "chain");
+  //chain->Add("../rootfiles/old_rootfiles/calib0307.root");
+  //chain->Add("../rootfiles/old_rootfiles/calib0308.root");
+
+  Int_t mux[32];
+  tree->SetBranchAddress("madc2", mux);
+
+
+  //TH1I *hist1 = new TH1I("hist1","mux1-1p1",400,350,750);
+  //TH1I *hist2 = new TH1I("hist2","mux1-2p1",400,650,1050);
+  //TH1I *hist3 = new TH1I("hist3","mux2-1p1",400,800,1200);
+  //TH1I *hist4 = new TH1I("hist4","mux2-2p1",400,1250,1650);
+  //TH1I *hist5 = new TH1I("hist5","mux3-1p1",400,1350,1750);
+  //TH1I *hist6 = new TH1I("hist6","mux3-2p1",400,1550,1950);
+  TH1I *hist1 = new TH1I("hist1","mux1-1p2",400,350,750);
+  TH1I *hist2 = new TH1I("hist2","mux1-2p2",400,650,1050);
+  TH1I *hist3 = new TH1I("hist3","mux2-1p2",400,800,1200);
+  TH1I *hist4 = new TH1I("hist4","mux2-2p2",400,1250,1650);
+  TH1I *hist5 = new TH1I("hist5","mux3-1p2",400,1350,1750);
+  TH1I *hist6 = new TH1I("hist6","mux3-2p2",400,1550,1950);
+
+  const Int_t N = tree->GetEntries();
+  const Int_t start_ent = 0;
+  const Int_t end_ent = 1000000;
+  if(end_ent > N){
+    cout << "Value Miss!" << endl;
+  }
+
+  for(Int_t ientry=start_ent; ientry<end_ent; ientry++){
+    tree->GetEntry(ientry);
+
+    hist1->Fill(mux[3]);
+    hist2->Fill(mux[7]);
+    hist3->Fill(mux[19]);
+    hist4->Fill(mux[15]);
+    hist5->Fill(mux[19]);
+    hist6->Fill(mux[23]);
+  }
+
+
+  TCanvas *c1 = new TCanvas("c1", "c1", 800, 1000);
+  c1->Divide(2, 3);
+  c1->cd(1);
+  hist1->Draw();
+  //tree->Draw("madc2[2]>>MUX1_1p1(400,350,750)", "Row<100"); //MUX1-1 pos1
+
+  c1->cd(2);
+  hist2->Draw();
+  //tree->Draw("madc2[6]>>MUX1_2p1(400,650,1050)"); //MUX1-2 pos1
+
+  c1->cd(3);
+  hist3->Draw();
+  //tree->Draw("madc2[18]>>MUX2_1p1(400,800,1200)"); //MUX2-1 pos1
+
+  c1->cd(4);
+  hist4->Draw();
+  //tree->Draw("madc2[14]>>MUX2_2p1(400,1250,1650)"); //MUX2-2 pos1
+
+  c1->cd(5);
+  hist5->Draw();
+  //tree->Draw("madc2[18]>>MUX3_1p1(400,1350,1750)"); //MUX3-1 pos1
+
+  c1->cd(6);
+  hist6->Draw();
+  //tree->Draw("madc2[22]>>MUX3_2p1(400,1550,1950)"); //MUX3-2 pos1
+
+  c1->Print("../figure/alpha_mpos2.png");
+}
diff --git a/main.cpp b/main.cpp
index 2d8f117394d83e7894d2109ecd400edb8870dc65..b256ada3d77abd8434ea0f80e1acf9f8031d8716 100644
--- a/main.cpp
+++ b/main.cpp
@@ -14,17 +14,6 @@ using namespace std;
 
 Int_t main(Int_t argc, Char_t **argv)
 {
-  //map tree is require to make calibration tree
-  bool rawdata = true;
-  bool mapdata = true;
-  bool calibration = true;
-
-  if(mapdata == false && calibration == true){
-    cout << "ERROR: calibration tree require to use map tree" << endl;
-    cout << "\tCHANGE mapdata = true" << endl;
-    return 0;
-  }
-
   bool print_progress = true;
   //prepare recipe.yml (assume that execute in build directory)
   TString yamlfile = "../recipe/recipe_si26a.yml";
@@ -37,19 +26,13 @@ Int_t main(Int_t argc, Char_t **argv)
   TCordferBranchManager *branch_manager = new TCordferBranchManager(filename[0], filename[1]);
   branch_manager->Readyaml(yamlfile);
   branch_manager->CreateRootFile();
-  if(rawdata){ branch_manager->CreateRawTree(); }
-  if(mapdata){ branch_manager->CreateMapTree(); }
-  if(calibration){ branch_manager->CreateCalibTree(); }
+  branch_manager->CreateTree();
 
   //prepare branch
-  if(rawdata){ branch_manager->CreateRawBranch(); }
-  if(mapdata){ branch_manager->CreateMapBranch(); }
-  if(calibration){ branch_manager->CreateCalibBranch(); }
+  branch_manager->CreateBranch();
 
   //map segment_id and branch
-  if(rawdata){ branch_manager->CreateRawMapping(); }
-  if(mapdata){ branch_manager->CreateMapping(); }
-  if(calibration){ branch_manager->CreateCalibMapping(); }
+  branch_manager->CreateMapping();
 
   //start to decode using anaroot
   TArtEventStore *estore = new TArtEventStore();
@@ -59,9 +42,7 @@ Int_t main(Int_t argc, Char_t **argv)
 
   Int_t evtn = 0;
   while(estore->GetNextEvent()){
-    if(rawdata){ branch_manager->ClearRawAll(); }
-    if(mapdata){ branch_manager->ClearMapAll(); }
-    if(calibration){ branch_manager->ClearCalibAll(); }
+    branch_manager->ClearAll();
 
     //eventloop
     for(Int_t i=0; i<rawevent->GetNumSeg(); i++){
@@ -74,26 +55,18 @@ Int_t main(Int_t argc, Char_t **argv)
         Int_t ch = d->GetCh();
         Int_t val = d->GetVal();
 
-        if(rawdata){ branch_manager->GiveRawValue(geo, ch, val); }
-        if(mapdata){ branch_manager->GiveMapValue(geo, ch, val); }
-        if(calibration){ branch_manager->GiveCalibValue(geo, ch, val); }
+        branch_manager->GiveValue(geo, ch, val);
       }
     }
-    // for process of MUX
-    if(calibration){ branch_manager->GiveWaitCalibValue(); }
 
-    if(rawdata){ branch_manager->RawFill(); }
-    if(mapdata){ branch_manager->MapFill(); }
-    if(calibration){ branch_manager->CalibFill(); }
+    branch_manager->Fill();
 
     estore->ClearData();
     if(print_progress && evtn%10000 == 0) { cout << "reading..." << evtn << endl; }
     evtn++;
   }
 
-  if(rawdata){ branch_manager->RawDataWrite(); }
-  if(mapdata){ branch_manager->DataWrite(); }
-  if(calibration){ branch_manager->CalibDataWrite(); }
+  branch_manager->DataWrite();
   branch_manager->FileClose();
 
   return 0;
diff --git a/recipe/recipe_si26a.yml b/recipe/recipe_si26a.yml
index 12b9c3db8f324e5c96621ae3c58d4f181ce6be2d..14067c9af60bdbfe23ffb87a240571f4bc1ff85c 100644
--- a/recipe/recipe_si26a.yml
+++ b/recipe/recipe_si26a.yml
@@ -1,30 +1,44 @@
-#tree information
+# tree information (in_use: on or off)
+# in_use: "on" or "off"
 raw_tree:
   name: "tree"
   description: "raw data tree"
+  in_use: on
 map_tree:
   name: "mtree"
   description: "mapping data tree"
+  in_use: on
 calib_tree:
   name: "ctree"
   description: "calibrate data tree"
+  in_use: on
 
-#mapfile and calibration file information
+
+# mapfile and calibration file information
+# det_flag
+#   1: coincidence
+#   2: rf
+#   3: PPAC
+#   4: ssd (dssd)
+#   5: MUX (MUX)
 map_setup:
   - name: coin
     mapfile: "../map/si26a/coin.map"
+    det_flag: 1
     calibfile:
       energy: ""
       timing: "../calibration/si26a/coin_t.prm"
 
   - name: dssd
     mapfile: "../map/si26a/dssd.map"
+    det_flag: 4
     calibfile:
       energy: "../calibration/si26a/dssd.prm"
       timing: "../calibration/si26a/dssd_t.prm"
 
   - name: mssd
     mapfile: "../map/si26a/mssd.map"
+    det_flag: 5
     calibfile:
       energy: "../calibration/si26a/mssd.prm"
       timing: "../calibration/si26a/mssd_t.prm"
@@ -32,53 +46,68 @@ map_setup:
 
   - name: ppac
     mapfile: "../map/si26a/ppac.map"
+    det_flag: 3
     calibfile:
       general: "../calibration/si26a/ppac.prm"
 
   - name: rf
     mapfile: "../map/si26a/rf.map"
+    det_flag: 2
     calibfile:
       energy: ""
       timing: "../calibration/si26a/rf_t.prm"
 
   - name: ssd
     mapfile: "../map/si26a/ssd.map"
+    det_flag: 4
     calibfile:
       energy: "../calibration/si26a/ssd.prm"
       timing: "../calibration/si26a/ssd_t.prm"
 
 
-#for rawdata tree
+# for rawdata tree
+# detector_id
+#   6: ADC
+#   7: TDC
+#   10: multihit TDC
 setup:
   - segment_no.: 1
     name: adc1
+    detector_id: 6
     channel: 32
 
   - segment_no.: 2
     name: adc2
+    detector_id: 6
     channel: 32
 
   - segment_no.: 6
     name: madc1
+    detector_id: 6
     channel: 32
 
   - segment_no.: 7
     name: madc2
+    detector_id: 6
     channel: 32
 
   - segment_no.: 11
     name: tdc1
+    detector_id: 7
     channel: 32
 
   - segment_no.: 12
     name: tdc2
+    detector_id: 7
     channel: 32
 
   - segment_no.: 16
     name: mhtdc
+    detector_id: 10
     branches:
       - name: mhtdc
         channel: 64
         maxhit: 12
       - name: mhtdc_nhit
         channel: 64
+
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9281a02ba7181d5ed760432582847bd2d4eac51f..3f3a7f69d3ecf8fa4872ea02bbd1c8c90e338bf9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,6 +1,6 @@
 add_library(sources SHARED
   CommandlineReader.cpp
-  ChannelMap.cpp
+  MapReader.cpp
   CalibParamReader.cpp
   CalibrationManager.cpp
   TCordferRawBranch.cpp
diff --git a/src/CommandlineReader.cpp b/src/CommandlineReader.cpp
index 07b27921302956508d632a22e05af7fcfdf4670d..a252bac50dd0283ef3d1bcac14759fb0542659f3 100644
--- a/src/CommandlineReader.cpp
+++ b/src/CommandlineReader.cpp
@@ -60,8 +60,8 @@ array<TString, 2> CheckCommandLine(Int_t argc, Char_t **argv)
     exit(0);
   }
 
-  cout << "\tinput file name  : " << finname << endl;
-  cout << "\toutput file name : " << foutname << endl;
+  cout << "-- input file name  : " << finname << endl;
+  cout << "-- output file name : " << foutname << endl;
 
   return {finname, foutname};
 }
diff --git a/src/ChannelMap.cpp b/src/MapReader.cpp
similarity index 94%
rename from src/ChannelMap.cpp
rename to src/MapReader.cpp
index 95ef6d49bb927f0c2343cf81a81aabd0f300f0cf..3cb65c2da9597739eaf2ef48232936fb32408408 100644
--- a/src/ChannelMap.cpp
+++ b/src/MapReader.cpp
@@ -6,12 +6,12 @@
 
 #include <TSystem.h>
 
-#include <ChannelMap.hh>
+#include <MapReader.hh>
 
 using namespace std;
 
 
-void ChannelMap::ReadMap() {
+void MapReader::ReadMap() {
   ifstream fin(filename.Data());
   string buf;
 
@@ -64,7 +64,7 @@ void ChannelMap::ReadMap() {
 }
 
 
-void ChannelMap::ReadMap(TString in_filename){
+void MapReader::ReadMap(TString in_filename){
   SetMapFile(in_filename);
   ReadMap();
 }
diff --git a/src/TCordferBranchManager.cpp b/src/TCordferBranchManager.cpp
index d4be30029b2acef72a1291d1fa5176a8bc741789..d96cc9903455f8d65247d5e81b4d0f355f9849bf 100644
--- a/src/TCordferBranchManager.cpp
+++ b/src/TCordferBranchManager.cpp
@@ -16,7 +16,6 @@
 #include <TArtCore.hh>
 
 #include "TCordferBranchManager.hh"
-#include "CalibrationManager.hh"
 
 using namespace std;
 
@@ -28,6 +27,33 @@ void TCordferBranchManager::Readyaml(TString yamlfile){
     exit(0);
   }
   recipe = YAML::LoadFile(yamlfile.Data());
+  cout << "-- yaml file:  " << yamlfile << endl;
+
+  if(recipe["raw_tree"]["in_use"].as<string>() == "on"){
+    rawdata=true;
+    cout << "\t-- raw_tree in use" << endl;
+  }
+  if(recipe["map_tree"]["in_use"].as<string>() == "on"){
+    mapdata=true;
+    cout << "\t-- map_tree in use" << endl;
+  }
+  if(recipe["calib_tree"]["in_use"].as<string>() == "on"){
+    calibration=true;
+    cout << "\t-- calib_tree in use" << endl;
+  }
+
+  if(mapdata == false && calibration == true){
+    cout << "ERROR: calibration tree require to use map tree" << endl;
+    cout << "\tCHANGE recipe in yaml file" << endl;
+    exit(0);
+  }
+}
+
+
+void TCordferBranchManager::CreateTree(){
+  if(rawdata){ CreateRawTree(); }
+  if(mapdata){ CreateMapTree(); }
+  if(calibration){ CreateCalibTree(); }
 }
 
 
@@ -55,31 +81,36 @@ void TCordferBranchManager::CreateCalibTree(){
 }
 
 
+void TCordferBranchManager::CreateBranch(){
+  if(rawdata){ CreateRawBranch(); }
+  if(mapdata){ CreateMapBranch(); }
+  if(calibration){ CreateCalibBranch(); }
+}
+
+
 void TCordferBranchManager::CreateRawBranch(){
   YAML::Node setup = recipe["setup"].as<YAML::Node>();
   for(Int_t i=0; i<setup.size(); i++){
     Int_t seg_id = setup[i]["segment_no."].as<int>();
     TString bname = setup[i]["name"].as<string>();
-    if(bname != "mhtdc"){
-    //if(string(bname.Data()).find("mhtdc") == string::npos){
+    Int_t det_id = setup[i]["detector_id"].as<int>();
+
+    if(det_id != 10){
       Int_t nch = setup[i]["channel"].as<int>();
-      TCordferRawBranch *raw_branch = new TCordferRawBranch(bname, nch);
-      raw_branch->Setgeo(seg_id);
-      raw_branch->MemorySet();
+      TCordferRawBranch *raw_branch = new TCordferRawBranch(bname, seg_id, nch, det_id);
 
       TString brancharray;
       brancharray.Form("%s[%d]/I", bname.Data(), raw_branch->size);
 
       tree->Branch(bname.Data(), raw_branch->bra_val, brancharray);
       branch.push_back(raw_branch);
+
     }else{
       TString mhtdc_name = setup[i]["branches"][0]["name"].as<string>();
       Int_t nch = setup[i]["branches"][0]["channel"].as<int>();
       Int_t nhit = setup[i]["branches"][0]["maxhit"].as<int>();
 
-      TCordferRawBranch *mhtdc_branch = new TCordferRawBranch(mhtdc_name, nch, nhit);
-      mhtdc_branch->Setgeo(seg_id);
-      mhtdc_branch->TwoDimMemorySet();
+      TCordferRawBranch *mhtdc_branch = new TCordferRawBranch(mhtdc_name, seg_id, nch, det_id, nhit);
 
       TString brancharray;
       brancharray.Form("%s[%d][%d]/I", mhtdc_name.Data(), mhtdc_branch->size, mhtdc_branch->nhit);
@@ -87,11 +118,10 @@ void TCordferBranchManager::CreateRawBranch(){
       tree->Branch(mhtdc_name.Data(), mhtdc_branch->mhtdc_val, brancharray);
       branch.push_back(mhtdc_branch);
 
+
       TString nhit_name = setup[i]["branches"][1]["name"].as<string>();
-      Int_t ch = setup[i]["branches"][1]["channel"].as<int>();
-      TCordferRawBranch *nhit_branch = new TCordferRawBranch(nhit_name, ch);
-      nhit_branch->Setgeo(-1);
-      nhit_branch->MemorySet();
+      Int_t nhit_nch = setup[i]["branches"][1]["channel"].as<int>();
+      TCordferRawBranch *nhit_branch = new TCordferRawBranch(nhit_name, 0, nhit_nch, 0); //geo, det_id = 0
 
       TString nhitbrancharray;
       nhitbrancharray.Form("%s[%d]/I", nhit_name.Data(), nhit_branch->size);
@@ -102,23 +132,18 @@ void TCordferBranchManager::CreateRawBranch(){
   }
 }
 
+
 void TCordferBranchManager::CreateMapBranch(){
   YAML::Node map_setup = recipe["map_setup"].as<YAML::Node>();
   for(Int_t i=0; i<map_setup.size(); i++){
     TString mname = map_setup[i]["mapfile"].as<string>();
+    Int_t det_id = map_setup[i]["det_flag"].as<int>();
 
-    FileStat_t info;
-    if(gSystem->GetPathInfo(mname.Data(), info) != 0){
-      cerr << "EROOR: in yaml File, '" << mname.Data() << "' does not exist." << endl;
-      exit(0);
-    }
-
-    ChannelMap *mfile = new ChannelMap(mname);
+    MapReader *mfile = new MapReader(mname);
     for(Int_t j=0; j<mfile->detector_name.size(); j++){
       TString bname = mfile->detector_name[j];
-      TCordferMapBranch *map_branch = new TCordferMapBranch(bname, mfile->segment_id[j].size());
-      map_branch->CopyMapInfo(mfile->segment_id[j], mfile->channel[j]);
-      map_branch->MemorySet();
+      TCordferMapBranch *map_branch = new TCordferMapBranch(bname, det_id, mfile->segment_id[j].size());
+      map_branch->SetMapInfo(mfile->segment_id[j], mfile->channel[j]);
 
       TString brancharray;
       brancharray.Form("%s[%d]/I", bname.Data(), map_branch->size);
@@ -129,15 +154,18 @@ void TCordferBranchManager::CreateMapBranch(){
   }
 }
 
+
 void TCordferBranchManager::CreateCalibBranch(){
   YAML::Node map_setup = recipe["map_setup"].as<YAML::Node>();
   for(Int_t i=0; i<map_setup.size(); i++){
     TString det_name = map_setup[i]["name"].as<string>();
+    Int_t det_id = map_setup[i]["det_flag"].as<int>();
 
     //**************
-    if(det_name == "ppac"){ continue; }
+    if(det_id == 3){ continue; } //for PPAC
     //**************
 
+    //default (except of PPAC)
     TString cname[2];
     cname[0] = map_setup[i]["calibfile"]["energy"].as<string>();
     cname[1] = map_setup[i]["calibfile"]["timing"].as<string>();
@@ -154,7 +182,7 @@ void TCordferBranchManager::CreateCalibBranch(){
       CalibParamReader *cfile = new CalibParamReader(det_name, cname[j]);
       for(Int_t k=0; k<cfile->branch_name.size(); k++){
         TString bname = cfile->branch_name[k];
-        TCordferCalibBranch *calib_branch = new TCordferCalibBranch(bname);
+        TCordferCalibBranch *calib_branch = new TCordferCalibBranch(bname, det_id);
         calib_branch->CopyCalibInfo(cfile->dim, cfile->parameters[k]);
 
         TString brancharray;
@@ -170,7 +198,7 @@ void TCordferBranchManager::CreateCalibBranch(){
         cbranch.push_back(calib_branch);
       }
     }
-    if(det_name == "mssd"){
+    if(det_id == 5){ //for parameter reader of MUX position (mssd)
       TString pos_name = map_setup[i]["calibfile"]["position"].as<string>();
       FileStat_t info;
       if(gSystem->GetPathInfo(pos_name.Data(), info) != 0){
@@ -187,143 +215,185 @@ void TCordferBranchManager::CreateCalibBranch(){
 }
 
 
+void TCordferBranchManager::CreateMapping(){
+  if(rawdata){ CreateRawMapping(); }
+  if(mapdata){ CreateMapMapping(); }
+  if(calibration){ CreateCalibMapping(); }
+}
+
+
 void TCordferBranchManager::CreateRawMapping(){
+  memset(rmapping, -1, sizeof(rmapping));
   for(Int_t i=0; i<branch.size(); i++){
     Int_t seg = branch[i]->geo;
-    mapping[seg] = i;
+    rmapping[seg] = i;
   }
 }
 
 
-void TCordferBranchManager::CreateMapping(){
+void TCordferBranchManager::CreateMapMapping(){
+  Int_t m = sizeof(mmapping) / sizeof(mmapping[0]);
+  Int_t n = sizeof(mmapping[0]) / sizeof(mmapping[0][0]);
+  memset(mmapping, -1, sizeof(mmapping[0][0])*m*n);
+
   for(Int_t i=0; i<mbranch.size(); i++){
     for(Int_t j=0; j<mbranch[i]->size; j++){
-      Int_t seg = mbranch[i]->segment_id[j]*1000 + mbranch[i]->channel[j];
-      Int_t index = i*1000 + j;
-      mmapping[seg] = index;
+      mmapping[mbranch[i]->segment_id[j]][mbranch[i]->channel[j]] = MakeBranchChannelIndex(i, j);
     }
   }
 }
 
 
 void TCordferBranchManager::CreateCalibMapping(){
-  Int_t mssd_tune = 0;
+  Int_t m = sizeof(cmapping) / sizeof(cmapping[0]);
+  Int_t n = sizeof(cmapping[0]) / sizeof(cmapping[0][0]);
+  memset(cmapping, -1, sizeof(cmapping[0][0])*m*n);
+
+  Int_t M = sizeof(muxmapping) / sizeof(muxmapping[0]);
+  Int_t N = sizeof(muxmapping[0]) / sizeof(muxmapping[0][0]);
+  memset(muxmapping, -1, sizeof(muxmapping[0][0])*M*N);
+
+  Int_t coin_num = 0;
+  Int_t rf_num = 0;
+  Int_t mssd_num = 0;
+  Int_t mux_num = 0;
+  Int_t mux_t_num = 0;
+
   for(Int_t i=0; i<cbranch.size(); i++){
-    string cbranch_name = string(cbranch[i]->GetBranchName().Data());
 
-    //for rf data
-    if(cbranch_name.find("RF1") != string::npos){
-      for(Int_t j=0; j<mbranch.size(); j++){
-        string mbranch_name = string(mbranch[j]->GetBranchName().Data());
-        if(mbranch_name.find("RF") != string::npos || mbranch_name.find("rf") != string::npos){
-          cbranch[i]->geo = mbranch[j]->segment_id[0];
-          cbranch[i]->ch = mbranch[j]->channel[0];
-        }
-      }
-    }else if(cbranch_name.find("RF2") != string::npos){
+    //for coin data
+    if(cbranch[i]->detector_id == 1){
+      Int_t coin_tmp = coin_num;
       for(Int_t j=0; j<mbranch.size(); j++){
-        string mbranch_name = string(mbranch[j]->GetBranchName().Data());
-        if(mbranch_name.find("RF") != string::npos || mbranch_name.find("rf") != string::npos){
-          cbranch[i]->geo = mbranch[j]->segment_id[1];
-          cbranch[i]->ch = mbranch[j]->channel[1];
+        if(mbranch[j]->detector_id == 1){
+          if(coin_tmp > 0){
+            coin_tmp--;
+            continue;
+          }else{
+            cbranch[i]->geo = mbranch[j]->segment_id[0];
+            cbranch[i]->ch = mbranch[j]->channel[0];
+            coin_num++;
+            break;
+          }
         }
       }
     }
 
-    //for coin data
-    else if(cbranch_name.find("coin") != string::npos){
+    //for rf data
+    if(cbranch[i]->detector_id == 2){
+      Int_t rf_index;
       for(Int_t j=0; j<mbranch.size(); j++){
-        string mbranch_name = string(mbranch[j]->GetBranchName().Data());
-        if(cbranch_name == mbranch_name){
-          cbranch[i]->geo = mbranch[j]->segment_id[0];
-          cbranch[i]->ch = mbranch[j]->channel[0];
-        }
+        if(mbranch[j]->detector_id == 2){ rf_index = j; }
       }
-    }
-
-    //for mssd
-    else if(cbranch_name.find("mssd") != string::npos && cbranch_name.substr(0, 2) != "t_"){
-      mssd_tune++;
-      if(mssd_tune%16 == 1){
-        Int_t mux_id = mssd_tune/16;
-        cbranch[i]->mpos1_prm = mpos[2*mux_id];
-        cbranch[i]->mpos2_prm = mpos[2*mux_id + 1];
-
-        Int_t seg0, seg1, seg2, seg3;
-
-        for(Int_t j=0; j<mbranch.size(); j++){
-          string mbranch_name = string(mbranch[j]->GetBranchName().Data());
-          if(cbranch_name.find(mbranch_name) != string::npos){
-            seg0 = mbranch[j]->segment_id[0]*1000 + mbranch[j]->channel[0];
-            cmapping[seg0] = i;
-            muxmapping[seg0] = 1;
-
-            seg1 = mbranch[j]->segment_id[1]*1000 + mbranch[j]->channel[1];
-            cmapping[seg1] = i;
-            muxmapping[seg1] = 2;
-
-            seg2 = mbranch[j]->segment_id[2]*1000 + mbranch[j]->channel[2];
-            cmapping[seg2] = i;
-            muxmapping[seg2] = 3;
-
-            seg3 = mbranch[j]->segment_id[3]*1000 + mbranch[j]->channel[3];
-            cmapping[seg2] = i;
-            muxmapping[seg2] = 4;
-          }
-        }
-        //cout << i << " " << cbranch_name << " " << seg0 << ", " << seg1 << ", " << seg2 << ", " << seg3 << endl;
-        continue;
+      if(rf_num == 0){
+        cbranch[i]->geo = mbranch[rf_index]->segment_id[0];
+        cbranch[i]->ch = mbranch[rf_index]->channel[0];
+        rf_num++;
+      }else if(rf_num == 1){
+        cbranch[i]->geo = mbranch[rf_index]->segment_id[1];
+        cbranch[i]->ch = mbranch[rf_index]->channel[1];
+        rf_num++;
       }else{
-        //cout << i << " " << cbranch_name << endl;
-        continue;
-      }
-    }else if(cbranch_name.find("mssd") != string::npos && cbranch_name.substr(0, 2) == "t_"){
-      for(Int_t j=0; j<mbranch.size(); j++){
-        string mbranch_name = string(mbranch[j]->GetBranchName().Data());
-        if(cbranch_name.find(mbranch_name) != string::npos){
-          cbranch[i]->geo = mbranch[j]->segment_id[4];
-          cbranch[i]->ch = mbranch[j]->channel[4];
-        }
+        cout << "WARNING: format of mapfile of rf is differenet" << endl;
       }
     }
 
     //for ppac
-    //else if(){}
+    //if(cbranch[i]->detector_id == 3){}
+
 
     //for dssd, ssd data
-    else{
-      bool tdc_flag = false;
-      if(cbranch_name.substr(0, 2) == "t_"){
-        cbranch_name.erase(0, 2);
-        tdc_flag = true;
-      }
-      for(Int_t j=0; j<mbranch.size(); j++){
-        string mbranch_name = string(mbranch[j]->GetBranchName().Data());
-        if(cbranch_name == mbranch_name){
-          if(tdc_flag){
-            cbranch[i]->geo = mbranch[j]->segment_id[1];
-            cbranch[i]->ch = mbranch[j]->channel[1];
-          }else{
-            cbranch[i]->geo = mbranch[j]->segment_id[0];
-            cbranch[i]->ch = mbranch[j]->channel[0];
+    if(cbranch[i]->detector_id == 4){
+      continue;
+    }
+    //else{
+    //  bool tdc_flag = false;
+    //  if(cbranch_name.substr(0, 2) == "t_"){
+    //    cbranch_name.erase(0, 2);
+    //    tdc_flag = true;
+    //  }
+    //  for(Int_t j=0; j<mbranch.size(); j++){
+    //    string mbranch_name = string(mbranch[j]->GetBranchName().Data());
+    //    if(cbranch_name == mbranch_name){
+    //      if(tdc_flag){
+    //        cbranch[i]->geo = mbranch[j]->segment_id[1];
+    //        cbranch[i]->ch = mbranch[j]->channel[1];
+    //      }else{
+    //        cbranch[i]->geo = mbranch[j]->segment_id[0];
+    //        cbranch[i]->ch = mbranch[j]->channel[0];
+    //      }
+    //    }
+    //  }
+    //}
+
+
+    //for mssd
+    if(cbranch[i]->detector_id == 5){
+      if(cbranch[i]->adc == true){
+        mssd_num++;
+        if(mssd_num%16 == 1){
+          Int_t mux_id = mssd_num/16;
+          cbranch[i]->mpos1_prm = mpos[2*mux_id];
+          cbranch[i]->mpos2_prm = mpos[2*mux_id + 1];
+
+          Int_t mux_tmp = mux_num;
+          for(Int_t j=0; j<mbranch.size(); j++){
+            if(mbranch[j]->detector_id == 5){
+              if(mux_tmp > 0){
+                mux_tmp--;
+                continue;
+              }else{
+                //cout << cbranch[i]->GetBranchName() << " " << mbranch[j]->GetBranchName() << endl;
+                for(Int_t k=0; k<4; k++){
+                  cmapping[mbranch[j]->segment_id[k]][mbranch[j]->channel[k]] = i;
+                  muxmapping[mbranch[j]->segment_id[k]][mbranch[j]->channel[k]] = k + 1;
+                }
+                mux_num++;
+                break;
+              }
+            }
           }
         }
+      }else if(cbranch[i]->adc == false){
+        Int_t mux_t_tmp = mux_t_num;
+        for(Int_t j=0; j<mbranch.size(); j++){
+          if(mbranch[j]->detector_id == 5){
+            if(mux_t_tmp > 0){
+              mux_t_tmp--;
+              continue;
+            }else{
+              //cout << cbranch[i]->GetBranchName() << " " << mbranch[j]->GetBranchName() << endl;
+              cmapping[mbranch[j]->segment_id[4]][mbranch[j]->channel[4]] = i;
+
+              mux_t_num++;
+              break;
+            }
+          }
+        }
+
       }
+      continue;
     }
 
-    Int_t seg = cbranch[i]->geo*1000 + cbranch[i]->ch;
-    Int_t index = i;
-    cmapping[seg] = index;
+    cmapping[cbranch[i]->geo][cbranch[i]->ch] = i;
 
     //cout << i << " " << cbranch_name << " " << seg << endl;
   }
 }
 
 
+void TCordferBranchManager::GiveValue(Int_t geo, Int_t ch, Int_t val){
+  if(rawdata){ GiveRawValue(geo, ch, val); }
+  if(mapdata){ GiveMapValue(geo, ch, val); }
+  if(calibration){ GiveCalibValue(geo, ch, val); }
+}
+
+
 void TCordferBranchManager::GiveRawValue(Int_t geo, Int_t ch, Int_t val){
+  Int_t index = rmapping[geo];
+
   //if not register segment
-  auto itr = mapping.find(geo);
-  if(itr == mapping.end()){
+  if(index < 0){
     if(rmapflag == false){
       cout << "WARNING: rmapping is not completed" << endl;
     }
@@ -331,12 +401,10 @@ void TCordferBranchManager::GiveRawValue(Int_t geo, Int_t ch, Int_t val){
     return;
   }
 
-  Int_t index = mapping[geo];
-
-  if(branch[index]->GetBranchName() == "mhtdc"){
-    Int_t ht_id = branch[mapping[-1]]->bra_val[ch];
+  if(branch[index]->detector_id == 10){
+    Int_t ht_id = branch[index+1]->bra_val[ch];
     branch[index]->mhtdc_val[ch][ht_id] = val;
-    branch[mapping[-1]]->bra_val[ch] += 1;
+    branch[index+1]->bra_val[ch] += 1;
   }else{
     branch[index]->bra_val[ch] = val;
   }
@@ -344,172 +412,100 @@ void TCordferBranchManager::GiveRawValue(Int_t geo, Int_t ch, Int_t val){
 
 
 void TCordferBranchManager::GiveMapValue(Int_t geo, Int_t ch, Int_t val){
-  Int_t seg = geo*1000 + ch;
-
-  //if not register segment
-  auto itr = mmapping.find(seg);
-  if(itr == mmapping.end()){
-    if(mapflag == false){
-      cout << "WARNING: mapping is not completed" << endl;
+  Int_t index = mmapping[geo][ch];
+  if(index < 0){
+    if(mmapflag == false){
+      cout << "-- WARNING: mmapping is not completed" << endl;
     }
-    mapflag=true;
+    mmapflag=true;
     return;
   }
 
-  Int_t index = mmapping[seg];
-  Int_t j = index % 1000;
-  Int_t i = (index - j)/1000;
+  array<Int_t, 2> index_array = GetBranchChannelIndex(index);
+  Int_t i = index_array[0];
+  Int_t j = index_array[1];
 
   mbranch[i]->bra_val[j] = val;
 }
 
 
 void TCordferBranchManager::GiveCalibValue(Int_t geo, Int_t ch, Int_t val){
-  Int_t seg = geo*1000 + ch;
-
-  //if not register segment
-  auto itr = cmapping.find(seg);
-  if(itr == cmapping.end()){
+  Int_t index = cmapping[geo][ch];
+  Int_t mux_id = muxmapping[geo][ch];
+  if(index < 0){
     if(cmapflag == false){
-      cout << "WARNING: cmapping is not completed" << endl;
+      cout << "-- WARNING: cmapping is not completed" << endl;
     }
     cmapflag=true;
     return;
   }
 
-  Int_t index = cmapping[seg];
-  string cbranch_name = string(cbranch[index]->GetBranchName().Data());
-
-  //for mssd energy calibration
-  if(cbranch_name.find("mssd") != string::npos && cbranch_name.substr(0, 2) != "t_"){
-    Int_t mux_sig = muxmapping[seg];
-    if(mux_sig==1 && cbranch[index]->mux_pos1==false){
-      cbranch[index]->SetGeometrytmp1(geo, ch, val);
-      cbranch[index]->mux_status1=true;
-
-    }else if(mux_sig==1 && cbranch[index]->mux_pos1==true){
-      if(cbranch[index]->mux1_junk == true){ return; }
-      Int_t add_ch = cbranch[index]->mux_ch1;
-      cbranch[index + add_ch]->cbra_val = GetCalibValue(val, cbranch[index+add_ch]->calib_param);
-
-    }else if(mux_sig==2 && cbranch[index]->mux_pos2==false){
-      cbranch[index]->SetGeometrytmp2(geo, ch, val);
-      cbranch[index]->mux_status2=true;
-
-    }else if(mux_sig==2 && cbranch[index]->mux_pos2==true){
-      if(cbranch[index]->mux2_junk == true){ return; }
-      Int_t add_ch = cbranch[index]->mux_ch2;
-      cbranch[index + add_ch]->cbra_val = GetCalibValue(val, cbranch[index+add_ch]->calib_param);
-
-    }else if(mux_sig==3){
-      cbranch[index]->mux_pos1 = true;
-      for(Int_t i=0; i<16; i++){
-        if(cbranch[index]->mpos1_prm[i] < val && cbranch[index]->mpos1_prm[i+1] > val){
-          cbranch[index]->mux_ch1 = i;
-        }
-      }
-      if(cbranch[index]->mux_ch1 < 0){ cbranch[index]->mux1_junk = true; }
+  //calib_status
+  //  0->not mux, 1->first mux signal, other -> "val" buffer
+  Int_t calib_status = cbranch[index]->GetCalibStatus(val, mux_id);
+  if(calib_status == 1){ return; }
+  else if(calib_status == 0){ cbranch[index]->SetCalibValue(val); }
+  else{
+    Int_t add_ch = cbranch[index]->GetAddBranchIndex(mux_id); // for MUX (default = 0)
+    if(add_ch == -1){ return; }
+    cbranch[index + add_ch]->SetCalibValue(calib_status);
+  }
+}
 
-    }else if(mux_sig==4){
-      cbranch[index]->mux_pos2 = true;
-      for(Int_t i=0; i<16; i++){
-        if(cbranch[index]->mpos2_prm[i] < val && cbranch[index]->mpos2_prm[i+1] > val){
-          cbranch[index]->mux_ch2 = i;
-        }
-      }
-      if(cbranch[index]->mux_ch2 < 0){ cbranch[index]->mux2_junk = true; }
-    }
 
-  //for others
-  }else{
-    if(cbranch[index]->adc){
-      cbranch[index]->cbra_val = GetCalibValue(val, cbranch[index]->calib_param);
-    }else{
-      cbranch[index]->cbra_tval[cbranch[index]->count_hit] = GetCalibValue(val, cbranch[index]->calib_param);
-      cbranch[index]->count_hit++;
-    }
-  }
+void TCordferBranchManager::Fill(){
+  if(rawdata){ RawFill(); }
+  if(mapdata){ MapFill(); }
+  if(calibration){ CalibFill(); }
 }
 
 
-void TCordferBranchManager::GiveWaitCalibValue(){
-  for(Int_t i=0; i<cbranch.size(); i++){
-    if(cbranch[i]->mux_status1==true){ GiveCalibValue(cbranch[i]->geo_tmp1, cbranch[i]->ch_tmp1, cbranch[i]->val_tmp1); }
-    if(cbranch[i]->mux_status2==true){ GiveCalibValue(cbranch[i]->geo_tmp2, cbranch[i]->ch_tmp2, cbranch[i]->val_tmp2); }
-  }
+void TCordferBranchManager::ClearAll(){
+  if(rawdata){ ClearRawAll(); }
+  if(mapdata){ ClearMapAll(); }
+  if(calibration){ ClearCalibAll(); }
 }
 
 
 void TCordferBranchManager::ClearRawAll(){
   for(Int_t i=0; i<branch.size(); i++){
-    if(branch[i]->GetBranchName() == "mhtdc"){
-      for(Int_t j=0; j<branch[i]->size; j++){
-        for(Int_t k=0; k<branch[i]->nhit; k++){
-          branch[i]->mhtdc_val[j][k] = -500;
-        }
-      }
-    }else if(branch[i]->GetBranchName() == "mhtdc_nhit"){
-      for(Int_t j=0; j<branch[i]->size; j++){
-        branch[i]->bra_val[j] = 0;
-      }
-    }else{
-      for(Int_t j=0; j<branch[i]->size; j++){
-        branch[i]->bra_val[j] = -500;
-      }
-    }
+    branch[i]->Clear();
   }
 }
 
 
 void TCordferBranchManager::ClearMapAll(){
   for(Int_t i=0; i<mbranch.size(); i++){
-    for(Int_t j=0; j<mbranch[i]->size; j++){
-      mbranch[i]->bra_val[j] = -500;
-    }
+    mbranch[i]->Clear();
   }
 }
 
 
 void TCordferBranchManager::ClearCalibAll(){
   for(Int_t i=0; i<cbranch.size(); i++){
-    cbranch[i]->mux_status1=false;
-    cbranch[i]->mux_status2=false;
-    cbranch[i]->mux_pos1=false;
-    cbranch[i]->mux_pos2=false;
-    cbranch[i]->mux1_junk=false;
-    cbranch[i]->mux2_junk=false;
-    cbranch[i]->mux_ch1=-99;
-    cbranch[i]->mux_ch2=-99;
-    cbranch[i]->geo_tmp1=-99;
-    cbranch[i]->geo_tmp2=-99;
-    cbranch[i]->ch_tmp1=-99;
-    cbranch[i]->ch_tmp2=-99;
-    cbranch[i]->val_tmp1=-99;
-    cbranch[i]->val_tmp2=-99;
-
-    if(cbranch[i]->adc){
-      cbranch[i]->cbra_val = -500.5;
-    }else{
-      for(Int_t j=0; j<12; j++){
-        cbranch[i]->cbra_tval[j] = -500.5;
-      }
-      cbranch[i]->count_hit = 0;
-    }
+    cbranch[i]->Clear();
   }
 }
 
+
+void TCordferBranchManager::DataWrite(){
+  if(rawdata){ RawDataWrite(); }
+  if(mapdata){ MapDataWrite(); }
+  if(calibration){ CalibDataWrite(); }
+}
+
+
 void TCordferBranchManager::FileClose(){
   rootfile->Close();
   for(Int_t i=0; i<branch.size(); i++){
-    if(branch[i]->GetBranchName() == "mhtdc"){
-      branch[i]->FreeTwoDimMemory();
-    }else{
-      branch[i]->FreeMemory();
-    }
+    branch[i]->FreeAll();
   }
+
   for(Int_t i=0; i<mbranch.size(); i++){
     mbranch[i]->FreeMemory();
   }
+
+  //for cbranch
 }
 
 // for debug
diff --git a/src/TCordferCalibBranch.cpp b/src/TCordferCalibBranch.cpp
index 649b641089ceacf1fa47e2f83392f4e4a92b5e98..4f4bb971d5ab6e238d66eee0d29e082e2f90fff8 100644
--- a/src/TCordferCalibBranch.cpp
+++ b/src/TCordferCalibBranch.cpp
@@ -1,5 +1,7 @@
 #include <iostream>
 #include <vector>
+#include <array>
+#include <cmath>
 
 #include <TSystem.h>
 
@@ -17,3 +19,113 @@ void TCordferCalibBranch::CopyCalibInfo(Int_t dim, vector<Double_t> param){
   }
 }
 
+
+Int_t TCordferCalibBranch::GetCalibStatus(Int_t val, Int_t mux_id){
+  if(detector_id == 5){
+    if(adc == true){
+      if(mux_id == 1 && mux_pos1 == false){
+        mux_status1 = true;
+        val_tmp1 = val;
+        return 1;
+      }
+
+      else if(mux_id == 1 && mux_pos2 == true){
+        return val;
+      }
+
+      else if(mux_id == 2 && mux_pos2 == false){
+        mux_status2 = true;
+        val_tmp2 = val;
+        return 1;
+      }
+
+      else if(mux_id == 2 && mux_pos2 == true){
+        return val;
+      }
+
+      else if(mux_id == 3 && mux_status1 == false){
+        pval_tmp1 = val;
+        mux_pos1 = true;
+        return 1;
+      }
+
+      else if(mux_id == 3 && mux_status1 == true){
+        pval_tmp1 = val;
+        return val_tmp1;
+      }
+
+      else if(mux_id == 4 && mux_status2 == false){
+        pval_tmp2 = val;
+        mux_pos2 = true;
+        return 1;
+      }
+
+      else if(mux_id == 4 && mux_status2 == true){
+        pval_tmp2 = val;
+        return val_tmp2;
+      }
+
+      //else{ return val; }
+
+    }else{ return 0; }
+  }else{ return 0; }
+  return 0;
+}
+
+
+Int_t TCordferCalibBranch::GetAddBranchIndex(Int_t mux_id){
+  Int_t add_ch = -1;
+  if(mux_id == 1 || mux_id == 3){
+    for(Int_t i=0; i<16; i++){
+      if(mpos1_prm[i] < pval_tmp1 && mpos1_prm[i+1] > pval_tmp1){
+        add_ch = i;
+      }
+    }
+
+  }else if(mux_id == 2 || mux_id == 4){
+    for(Int_t i=0; i<16; i++){
+      if(mpos2_prm[i] < pval_tmp2 && mpos2_prm[i+1] > pval_tmp2){
+        add_ch = i;
+      }
+    }
+  }
+  return add_ch;
+}
+
+
+void TCordferCalibBranch::SetCalibValue(Int_t val){
+  if(adc == true){
+    cbra_val = GetCalibValue(val, calib_param);
+  }
+  else if(adc == false){
+    cbra_tval[count_hit] = GetCalibValue(val, calib_param);
+    count_hit++;
+  }
+}
+
+
+Double_t TCordferCalibBranch::GetCalibValue(Int_t val, vector<Double_t> params){
+  Double_t tmp = 0.0;
+  for(Int_t i=0; i<params.size(); i++){
+    tmp += params[i]*pow(val, i);
+  }
+  return tmp;
+}
+
+
+void TCordferCalibBranch::Clear(){
+  mux_status1=false;
+  mux_status2=false;
+  mux_pos1=false;
+  mux_pos2=false;
+  val_tmp1=-99;
+  val_tmp2=-99;
+  if(adc == true){
+    cbra_val = -500.5;
+  }else{
+    for(Int_t j=0; j<12; j++){
+      cbra_tval[j] = -500.5;
+    }
+    count_hit = 0;
+  }
+}
diff --git a/src/TCordferMapBranch.cpp b/src/TCordferMapBranch.cpp
index 1e8772ab65501a3816be194b1066cb0352f78352..321becb2185d5cb27f54ff83303aaabf3492e00d 100644
--- a/src/TCordferMapBranch.cpp
+++ b/src/TCordferMapBranch.cpp
@@ -1,5 +1,6 @@
 #include <iostream>
 #include <vector>
+#include <string>
 
 #include <TSystem.h>
 
@@ -8,8 +9,14 @@
 using namespace std;
 
 
-void TCordferMapBranch::CopyMapInfo(vector<Int_t> seg, vector<Int_t> ch){
+void TCordferMapBranch::SetMapInfo(vector<Int_t> seg, vector<Int_t> ch){
   copy(seg.begin(), seg.end(), back_inserter(segment_id));
   copy(ch.begin(), ch.end(), back_inserter(channel));
 }
 
+void TCordferMapBranch::Clear(){
+  //memset(bra_val, -500, sizeof(bra_val));
+  for(Int_t j=0; j<size; j++){
+    bra_val[j] = -500;
+  }
+}
diff --git a/src/TCordferRawBranch.cpp b/src/TCordferRawBranch.cpp
index 3547555ceeaa97dc358726d4d7344c8a7075a21e..e6a21afa33daefba75c05ab1bf51f4a0b4d2c97e 100644
--- a/src/TCordferRawBranch.cpp
+++ b/src/TCordferRawBranch.cpp
@@ -22,3 +22,48 @@ void TCordferRawBranch::FreeTwoDimMemory(){
   delete[] mhtdc_val;
 }
 
+
+//bool TCordferRawBranch::SetValue(Int_t ch, Int_t val){
+//  if(detector_id == 10){
+//  }
+//}
+
+
+void TCordferRawBranch::Clear(){
+  //if(detector_id == 10){
+  //  Int_t m = sizeof(mhtdc_val) / sizeof(mhtdc_val[0]);
+  //  Int_t n = sizeof(mhtdc_val[0]) / sizeof(mhtdc_val[0][0]);
+  //  memset(mhtdc_val, -500, sizeof(mhtdc_val[0][0])*m*n);
+  //}
+  //else if(detector_id == 0){
+  //  memset(bra_val, 0, sizeof(bra_val));
+  //}else{
+  //  memset(bra_val, -500, sizeof(bra_val));
+  //}
+
+  if(detector_id == 10){
+    for(Int_t j=0; j<size; j++){
+      for(Int_t k=0; k<nhit; k++){
+        mhtdc_val[j][k] = -500;
+      }
+    }
+  }else if(detector_id == 0){
+    for(Int_t j=0; j<size; j++){
+      bra_val[j] = 0;
+    }
+  }else{
+    for(Int_t j=0; j<size; j++){
+      bra_val[j] = -500;
+    }
+  }
+}
+
+
+
+void TCordferRawBranch::FreeAll(){
+  if(detector_id == 10){
+    FreeTwoDimMemory();
+  }else{
+    FreeMemory();
+  }
+}