//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// G4tgbGeometryDumper implementation
//
// Author: P.Arce, CIEMAT (November 2007)
// --------------------------------------------------------------------

#include "G4tgbGeometryDumper.hh"

#include "G4tgrMessenger.hh"

#include "G4UIcommand.hh"
#include "G4Material.hh"
#include "G4Element.hh"
#include "G4VSolid.hh"
#include "G4Box.hh"
#include "G4Tubs.hh"
#include "G4Cons.hh"
#include "G4Trap.hh"
#include "G4Sphere.hh"
#include "G4Orb.hh"
#include "G4Trd.hh"
#include "G4Para.hh"
#include "G4Torus.hh"
#include "G4Hype.hh"
#include "G4Polycone.hh"
#include "G4GenericPolycone.hh"
#include "G4Polyhedra.hh"
#include "G4EllipticalTube.hh"
#include "G4Ellipsoid.hh"
#include "G4EllipticalCone.hh"
#include "G4Hype.hh"
#include "G4Tet.hh"
#include "G4TwistedBox.hh"
#include "G4TwistedTrap.hh"
#include "G4TwistedTrd.hh"
#include "G4TwistedTubs.hh"
#include "G4MultiUnion.hh"
#include "G4ScaledSolid.hh"
#include "G4PVPlacement.hh"
#include "G4PVParameterised.hh"
#include "G4PVReplica.hh"
#include "G4BooleanSolid.hh"
#include "G4ReflectionFactory.hh"
#include "G4ReflectedSolid.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4PhysicalVolumeStore.hh"
#include "G4GeometryTolerance.hh"
#include "G4VPVParameterisation.hh"
#include "G4SystemOfUnits.hh"
#include <iomanip>

// --------------------------------------------------------------------
G4ThreadLocal G4tgbGeometryDumper* G4tgbGeometryDumper::theInstance = nullptr;

// --------------------------------------------------------------------
G4tgbGeometryDumper::G4tgbGeometryDumper()
{
}

// --------------------------------------------------------------------
G4tgbGeometryDumper* G4tgbGeometryDumper::GetInstance()
{
  if(theInstance == nullptr)
  {
    theInstance = new G4tgbGeometryDumper;
  }
  return theInstance;
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpGeometry(const G4String& fname)
{
  theFile = new std::ofstream(fname);

  G4VPhysicalVolume* pv = GetTopPhysVol();
  DumpPhysVol(pv);  // dump volume and recursively it will dump all hierarchy
}

// --------------------------------------------------------------------
G4VPhysicalVolume* G4tgbGeometryDumper::GetTopPhysVol()
{
  G4PhysicalVolumeStore* pvstore = G4PhysicalVolumeStore::GetInstance();
  G4VPhysicalVolume* pv = *(pvstore->cbegin());
  for(;;)
  {
    G4LogicalVolume* lv = pv->GetMotherLogical();
    if(lv == 0)
    {
      break;
    }

    //----- look for one PV of this LV
    for(auto ite = pvstore->cbegin(); ite != pvstore->cend(); ++ite)
    {
      pv = (*ite);
      if(pv->GetLogicalVolume() == lv)
      {
        break;
      }
    }
  }

  return pv;
}

// --------------------------------------------------------------------
G4tgbGeometryDumper::~G4tgbGeometryDumper()
{
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpPhysVol(G4VPhysicalVolume* pv)
{
  //--- Dump logical volume first
  G4LogicalVolume* lv = pv->GetLogicalVolume();

  G4ReflectionFactory* reffact = G4ReflectionFactory::Instance();

  //--- It is not needed to dump _refl volumes created when parent is reflected
  // !!WARNING : it must be avoided to reflect a volume hierarchy if children
  //             has also been reflected, as both will have same name

  if(reffact->IsReflected(lv) && reffact->IsReflected(pv->GetMotherLogical()))
  {
    return;
  }

  G4bool bVolExists = CheckIfLogVolExists(lv->GetName(), lv);

  //---- Construct this PV
  if(pv->GetMotherLogical() != nullptr)  // not WORLD volume
  {
    if(!pv->IsReplicated())
    {
      G4String lvName = lv->GetName();
      if(!bVolExists)
      {
        lvName = DumpLogVol(lv);
      }
      DumpPVPlacement(pv, lvName);
    }
    else if(pv->IsParameterised())
    {
      G4PVParameterised* pvparam = (G4PVParameterised*) (pv);
      DumpPVParameterised(pvparam);
    }
    else
    {
      G4String lvName = lv->GetName();
      if(!bVolExists)
      {
        lvName = DumpLogVol(lv);
      }
      G4PVReplica* pvrepl = (G4PVReplica*) (pv);
      DumpPVReplica(pvrepl, lvName);
    }
  }
  else
  {
    DumpLogVol(lv);
  }

  if(!bVolExists)
  {
    //---- Construct PV's who has this LV as mother
    std::vector<G4VPhysicalVolume*> pvChildren = GetPVChildren(lv);
    for(auto ite = pvChildren.cbegin(); ite != pvChildren.cend(); ++ite)
    {
      DumpPhysVol(*ite);
    }
  }
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpPVPlacement(G4VPhysicalVolume* pv,
                                          const G4String& lvName, G4int copyNo)
{
  G4String pvName = pv->GetName();

  G4RotationMatrix* rotMat = pv->GetRotation();
  if(rotMat == nullptr)
    rotMat = new G4RotationMatrix();

  //---- Check if it is reflected
  G4ReflectionFactory* reffact = G4ReflectionFactory::Instance();
  G4LogicalVolume* lv          = pv->GetLogicalVolume();
  if(reffact->IsReflected(lv))
  {
#ifdef G4VERBOSE
    if(G4tgrMessenger::GetVerboseLevel() >= 1)
    {
      G4cout << " G4tgbGeometryDumper::DumpPVPlacement() - Reflected volume: "
             << pv->GetName() << G4endl;
    }
#endif
    G4ThreeVector colx = rotMat->colX();
    G4ThreeVector coly = rotMat->colY();
    G4ThreeVector colz = rotMat->colZ();
    // apply a Z reflection (reflection matrix is decomposed in new
    // reflection-free rotation + z-reflection)
    colz *= -1.;
    G4Rep3x3 rottemp(colx.x(), coly.x(), colz.x(), colx.y(), coly.y(), colz.y(),
                     colx.z(), coly.z(), colz.z());
    // matrix representation (inverted)
    *rotMat = G4RotationMatrix(rottemp);
    *rotMat = (*rotMat).inverse();
    pvName += "_refl";
  }
  const G4String& rotName  = DumpRotationMatrix(rotMat);
  G4ThreeVector pos = pv->GetTranslation();

  if(copyNo == -999)  // for parameterisations copy number is provided
  {
    copyNo = pv->GetCopyNo();
  }

  const G4String& fullname = pvName + "#" + G4UIcommand::ConvertToString(copyNo)
                           + "/" + pv->GetMotherLogical()->GetName();

  if(!CheckIfPhysVolExists(fullname, pv))
  {
    (*theFile) << ":PLACE " << SubstituteRefl(AddQuotes(lvName)) << " "
               << copyNo << " "
               << SubstituteRefl(AddQuotes(pv->GetMotherLogical()->GetName()))
               << " " << AddQuotes(rotName) << " " << pos.x() << " " << pos.y()
               << " " << pos.z() << G4endl;

    thePhysVols[fullname] = pv;
  }
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpPVParameterised(G4PVParameterised* pv)
{
  G4String pvName = pv->GetName();

  EAxis axis;
  G4int nReplicas;
  G4double width;
  G4double offset;
  G4bool consuming;
  pv->GetReplicationData(axis, nReplicas, width, offset, consuming);

  G4VPVParameterisation* param = pv->GetParameterisation();

  G4LogicalVolume* lv             = pv->GetLogicalVolume();
  G4VSolid* solid1st              = param->ComputeSolid(0, pv);
  G4Material* mate1st             = param->ComputeMaterial(0, pv);
  std::vector<G4double> params1st = GetSolidParams(solid1st);
  std::vector<G4double> newParams;
  G4VSolid* newSolid = solid1st;
  G4String lvName;

  for(G4int ii = 0; ii < nReplicas; ++ii)
  {
    G4Material* newMate = param->ComputeMaterial(ii, pv);
    if(solid1st->GetEntityType() == "G4Box")
    {
      G4Box* box = (G4Box*) (solid1st);
      param->ComputeDimensions(*box, ii, pv);
      newParams = GetSolidParams(box);
      newSolid  = (G4VSolid*) box;
    }
    else if(solid1st->GetEntityType() == "G4Tubs")
    {
      G4Tubs* tubs = (G4Tubs*) (solid1st);
      param->ComputeDimensions(*tubs, ii, pv);
      newParams = GetSolidParams(tubs);
      newSolid  = (G4VSolid*) tubs;
    }
    else if(solid1st->GetEntityType() == "G4Trd")
    {
      G4Trd* trd = (G4Trd*) (solid1st);
      param->ComputeDimensions(*trd, ii, pv);
      newParams = GetSolidParams(trd);
      newSolid  = (G4VSolid*) trd;
    }
    else if(solid1st->GetEntityType() == "G4Trap")
    {
      G4Trap* trap = (G4Trap*) (solid1st);
      param->ComputeDimensions(*trap, ii, pv);
      newParams = GetSolidParams(trap);
      newSolid  = (G4VSolid*) trap;
    }
    else if(solid1st->GetEntityType() == "G4Cons")
    {
      G4Cons* cons = (G4Cons*) (solid1st);
      param->ComputeDimensions(*cons, ii, pv);
      newParams = GetSolidParams(cons);
      newSolid  = (G4VSolid*) cons;
    }
    else if(solid1st->GetEntityType() == "G4Sphere")
    {
      G4Sphere* sphere = (G4Sphere*) (solid1st);
      param->ComputeDimensions(*sphere, ii, pv);
      newParams = GetSolidParams(sphere);
      newSolid  = (G4VSolid*) sphere;
    }
    else if(solid1st->GetEntityType() == "G4Orb")
    {
      G4Orb* orb = (G4Orb*) (solid1st);
      param->ComputeDimensions(*orb, ii, pv);
      newParams = GetSolidParams(orb);
      newSolid  = (G4VSolid*) orb;
    }
    else if(solid1st->GetEntityType() == "G4Torus")
    {
      G4Torus* torus = (G4Torus*) (solid1st);
      param->ComputeDimensions(*torus, ii, pv);
      newParams = GetSolidParams(torus);
      newSolid  = (G4VSolid*) torus;
    }
    else if(solid1st->GetEntityType() == "G4Para")
    {
      G4Para* para = (G4Para*) (solid1st);
      param->ComputeDimensions(*para, ii, pv);
      newParams = GetSolidParams(para);
      newSolid  = (G4VSolid*) para;
    }
    else if(solid1st->GetEntityType() == "G4Polycone")
    {
      G4Polycone* polycone = (G4Polycone*) (solid1st);
      param->ComputeDimensions(*polycone, ii, pv);
      newParams = GetSolidParams(polycone);
      newSolid  = (G4VSolid*) polycone;
    }
    else if(solid1st->GetEntityType() == "G4Polyhedra")
    {
      G4Polyhedra* polyhedra = (G4Polyhedra*) (solid1st);
      param->ComputeDimensions(*polyhedra, ii, pv);
      newParams = GetSolidParams(polyhedra);
      newSolid  = (G4VSolid*) polyhedra;
    }
    else if(solid1st->GetEntityType() == "G4Hype")
    {
      G4Hype* hype = (G4Hype*) (solid1st);
      param->ComputeDimensions(*hype, ii, pv);
      newParams = GetSolidParams(hype);
      newSolid  = (G4VSolid*) hype;
    }
    if(ii == 0 || mate1st != newMate || params1st[0] != newParams[0])
    {
      G4String extraName = "";
      if(ii != 0)
      {
        extraName = "#" + G4UIcommand::ConvertToString(ii) + "/" +
                    pv->GetMotherLogical()->GetName();
      }
      lvName = DumpLogVol(lv, extraName, newSolid, newMate);
    }

    param->ComputeTransformation(ii, pv);
    DumpPVPlacement(pv, lvName, ii);
  }
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpPVReplica(G4PVReplica* pv, const G4String& lvName)
{
  EAxis axis;
  G4int nReplicas;
  G4double width;
  G4double offset;
  G4bool consuming;
  pv->GetReplicationData(axis, nReplicas, width, offset, consuming);
  G4String axisName;
  switch(axis)
  {
    case kXAxis:
      axisName = "X";
      break;
    case kYAxis:
      axisName = "Y";
      break;
    case kZAxis:
      axisName = "Z";
      break;
    case kRho:
      axisName = "R";
      break;
    case kPhi:
      axisName = "PHI";
      break;
    case kRadial3D:
    case kUndefined:
      G4String ErrMessage =
        "Unknown axis of replication for volume" + pv->GetName();
      G4Exception("G4tgbGeometryDumper::DumpPVReplica", "Wrong axis ",
                  FatalException, ErrMessage);
      break;
  }

  const G4String& fullname = lvName + "/" + pv->GetMotherLogical()->GetName();

  if(!CheckIfPhysVolExists(fullname, pv))
  {
    (*theFile) << ":REPL " << SubstituteRefl(AddQuotes(lvName)) << " "
               << SubstituteRefl(AddQuotes(pv->GetMotherLogical()->GetName()))
               << " " << axisName << " " << nReplicas;
    if(axis != kPhi)
    {
      (*theFile) << " " << width << " " << offset << G4endl;
    }
    else
    {
      (*theFile) << " " << width / deg << "*deg"
                 << " " << offset / deg << "*deg" << G4endl;
    }

    thePhysVols[fullname] = pv;
  }
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::DumpLogVol(G4LogicalVolume* lv,
                                         const G4String& extraName,
                                         G4VSolid* solid,
                                         G4Material* mate)
{
  G4String lvName;

  if(extraName == "")  //--- take out the '_refl' in the name
  {
    lvName = GetObjectName(lv, theLogVols);
  }
  else
  {
    lvName = lv->GetName() + extraName;
  }

  if(theLogVols.find(lvName) != theLogVols.cend())  // alredy dumped
  {
    return lvName;
  }

  if(solid == nullptr)
  {
    solid = lv->GetSolid();
  }

  //---- Dump solid
  const G4String& solidName = DumpSolid(solid, extraName);

  //---- Dump material
  if(mate == nullptr)
  {
    mate = lv->GetMaterial();
  }
  const G4String& mateName = DumpMaterial(mate);

  //---- Dump logical volume (solid + material)
  (*theFile) << ":VOLU " << SubstituteRefl(AddQuotes(lvName)) << " "
             << SupressRefl(AddQuotes(solidName)) << " " << AddQuotes(mateName)
             << G4endl;

  theLogVols[lvName] = lv;

  return lvName;
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::DumpMaterial(G4Material* mat)
{
  const G4String& mateName = GetObjectName(mat, theMaterials);
  if(theMaterials.find(mateName) != theMaterials.cend())  // alredy dumped
  {
    return mateName;
  }

  std::size_t numElements = mat->GetNumberOfElements();
  G4double density   = mat->GetDensity() / g * cm3;

  // start tag
  //
  if(numElements == 1)
  {
    (*theFile) << ":MATE " << AddQuotes(mateName) << " " << mat->GetZ() << " "
               << mat->GetA() / (g / mole) << " " << density << G4endl;
  }
  else
  {
    const G4ElementVector* elems = mat->GetElementVector();
    const G4double* fractions    = mat->GetFractionVector();
    for(std::size_t ii = 0; ii < numElements; ++ii)
    {
      DumpElement(const_cast<G4Element*>((*elems)[ii]));
    }

    (*theFile) << ":MIXT " << AddQuotes(mateName) << " " << density << " "
               << numElements << G4endl;
    // close start element tag and get ready to do composit "parts"
    for(std::size_t ii = 0; ii < numElements; ++ii)
    {
      (*theFile) << "   " << AddQuotes(GetObjectName(const_cast<G4Element*>((*elems)[ii]), theElements))
                 << " " << fractions[ii] << G4endl;
    }
  }

  (*theFile) << ":MATE_MEE " << AddQuotes(mateName) << " "
             << mat->GetIonisation()->GetMeanExcitationEnergy() / eV << "*eV"
             << G4endl;

  (*theFile) << ":MATE_TEMPERATURE " << AddQuotes(mateName) << " "
             << mat->GetTemperature() / kelvin << "*kelvin" << G4endl;

  (*theFile) << ":MATE_PRESSURE " << AddQuotes(mateName) << " "
             << mat->GetPressure() / atmosphere << "*atmosphere" << G4endl;

  G4State state = mat->GetState();
  G4String stateStr;
  switch(state)
  {
    case kStateUndefined:
      stateStr = "Undefined";
      break;
    case kStateSolid:
      stateStr = "Solid";
      break;
    case kStateLiquid:
      stateStr = "Liquid";
      break;
    case kStateGas:
      stateStr = "Gas";
      break;
  }

  (*theFile) << ":MATE_STATE " << AddQuotes(mateName) << " " << stateStr
             << G4endl;

  theMaterials[mateName] = mat;

  return mateName;
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpElement(G4Element* ele)
{
  const G4String& elemName = GetObjectName(ele, theElements);

  if(theElements.find(elemName) != theElements.cend())  // alredy dumped
  {
    return;
  }

  //--- Add symbol name: Material mixtures store the components as elements
  //    (even if the input are materials), but without symbol
  //
  G4String symbol = ele->GetSymbol();
  if(symbol == "" || symbol == " ")
  {
    symbol = elemName;
  }

  if(ele->GetNumberOfIsotopes() == 0)
  {
    (*theFile) << ":ELEM " << AddQuotes(elemName) << " " << AddQuotes(symbol)
               << " " << ele->GetZ() << " " << ele->GetA() / (g / mole) << " "
               << G4endl;
  }
  else
  {
    const G4IsotopeVector* isots = ele->GetIsotopeVector();
    for(std::size_t ii = 0; ii < ele->GetNumberOfIsotopes(); ++ii)
    {
      DumpIsotope((*isots)[ii]);
    }

    (*theFile) << ":ELEM_FROM_ISOT " << AddQuotes(elemName) << " "
               << AddQuotes(symbol) << " " << ele->GetNumberOfIsotopes()
               << G4endl;
    const G4double* fractions = ele->GetRelativeAbundanceVector();
    for(std::size_t ii = 0; ii < ele->GetNumberOfIsotopes(); ++ii)
    {
      (*theFile) << "   " << AddQuotes(GetObjectName((*isots)[ii], theIsotopes))
                 << " " << fractions[ii] << G4endl;
    }
  }
  theElements[elemName] = ele;
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpIsotope(G4Isotope* isot)
{
  const G4String& isotName = GetObjectName(isot, theIsotopes);
  if(theIsotopes.find(isotName) != theIsotopes.cend())  // alredy dumped
  {
    return;
  }

  (*theFile) << ":ISOT " << AddQuotes(isotName) << " " << isot->GetZ() << " "
             << isot->GetN() << " " << isot->GetA() / (g / mole) << " "
             << G4endl;

  theIsotopes[isotName] = isot;
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::DumpSolid(G4VSolid* solid,
                                        const G4String& extraName)
{
  G4String solidName;
  if(extraName == "")
  {
    solidName = GetObjectName(solid, theSolids);
  }
  else
  {
    solidName = solid->GetName() + extraName;
  }

  if(theSolids.find(solidName) != theSolids.cend())  // alredy dumped
  {
    return solidName;
  }

  G4String solidType = solid->GetEntityType();
  solidType          = GetTGSolidType(solidType);
  
  if(solidType == "UNIONSOLID")
  {
    DumpBooleanVolume("UNION", solid);
  }
  else if(solidType == "SUBTRACTIONSOLID")
  {
    DumpBooleanVolume("SUBTRACTION", solid);
  }
  else if(solidType == "INTERSECTIONSOLID")
  {
    DumpBooleanVolume("INTERSECTION", solid);
  }
  else if(solidType == "REFLECTEDSOLID")
  {
    G4ReflectedSolid* solidrefl = dynamic_cast<G4ReflectedSolid*>(solid);
    if(solidrefl == nullptr)
    {
      G4Exception("G4tgbGeometryDumper::DumpSolid()", "InvalidType",
                  FatalException, "Invalid reflected solid!");
      return solidName;
    }
    G4VSolid* solidori = solidrefl->GetConstituentMovedSolid();
    DumpSolid(solidori);
  }
  else if(solidType == "MULTIUNION")
  {
    DumpMultiUnionVolume(solid);
  }
  else if(solidType == "SCALEDSOLID")
  {
    DumpScaledVolume(solid);
  }
  else
  {
    (*theFile) << ":SOLID " << AddQuotes(solidName) << " ";
    (*theFile) << AddQuotes(solidType) << " ";
    DumpSolidParams( solid );
    theSolids[solidName] = solid;
  }

  return solidName;
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpBooleanVolume(const G4String& solidType,
                                            G4VSolid* so)
{
  G4BooleanSolid* bso = dynamic_cast<G4BooleanSolid*>(so);
  if(bso == nullptr)
  {
    return;
  }
  G4VSolid* solid0             = bso->GetConstituentSolid(0);
  G4VSolid* solid1             = bso->GetConstituentSolid(1);
  G4DisplacedSolid* solid1Disp = nullptr;
  G4bool displaced             = dynamic_cast<G4DisplacedSolid*>(solid1);
  if(displaced)
  {
    solid1Disp = dynamic_cast<G4DisplacedSolid*>(solid1);
    if(solid1Disp != nullptr)
    {
      solid1 = solid1Disp->GetConstituentMovedSolid();
    }
    else
    {
      return;
    }
  }
  DumpSolid(solid0);
  DumpSolid(solid1);

  G4String rotName;
  G4ThreeVector pos;
  if(displaced)
  {
    pos = solid1Disp->GetObjectTranslation();  // translation is of mother frame
    rotName = DumpRotationMatrix(new G4RotationMatrix(
      (solid1Disp->GetTransform().NetRotation()).inverse()));
  }
  else  // no displacement
  {
    rotName = DumpRotationMatrix(new G4RotationMatrix);
    pos     = G4ThreeVector();
  }

  const G4String& bsoName = GetObjectName(so, theSolids);
  if(theSolids.find(bsoName) != theSolids.cend()) return;  // alredy dumped
  const G4String& solid0Name = FindSolidName(solid0);
  const G4String& solid1Name = FindSolidName(solid1);

  (*theFile) << ":SOLID " << AddQuotes(bsoName) << " " << AddQuotes(solidType)
             << " " << AddQuotes(solid0Name) << " " << AddQuotes(solid1Name)
             << " " << AddQuotes(rotName) << " " << approxTo0(pos.x()) << " "
             << approxTo0(pos.y()) << " " << approxTo0(pos.z()) << " "
             << G4endl;

  theSolids[bsoName] = bso;
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpMultiUnionVolume( G4VSolid* so)
{
  const G4MultiUnion* muun = dynamic_cast<const G4MultiUnion*>(so);
  if(muun != nullptr)
    {
      G4int nSolids = muun->GetNumberOfSolids();
      std::vector<G4String> rotList;
      for( G4int iso = 0; iso < nSolids; iso++ ) {
	G4Transform3D trans = muun->GetTransformation(iso);
	const G4String& rotName = DumpRotationMatrix( new G4RotationMatrix(trans.getRotation()));
	rotList.push_back(rotName);
	G4VSolid* solN = muun->GetSolid(iso);
	DumpSolid(solN);
      }
      const G4String& bsoName = GetObjectName(const_cast<G4VSolid*>(so), theSolids);
      (*theFile) << ":SOLID " << AddQuotes(bsoName) << " MULTIUNION "
		 << nSolids;
      
      for( G4int iso = 0; iso < nSolids; ++iso ) {
	G4VSolid* solN = muun->GetSolid(iso);
	G4Transform3D trans = muun->GetTransformation(iso);
	G4ThreeVector pos = trans.getTranslation();  // translation is of mother frame
	(*theFile) << " " <<  solN->GetName()
		   << " " << " " << rotList[iso]
		   << " " << approxTo0(pos.x())
		   << " " << approxTo0(pos.y())
		   << " " << approxTo0(pos.z());
      }
      (*theFile) << G4endl;
      
    }
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpScaledVolume( G4VSolid* so)
{
  const G4ScaledSolid* ssol = dynamic_cast<const G4ScaledSolid*>(so);
  if(ssol != nullptr)
    {
      G4VSolid* unscaledSolid = ssol->GetUnscaledSolid();
      G4Scale3D scaleTransf = ssol->GetScaleTransform();
      G4String bsoName = GetObjectName(const_cast<G4VSolid*>(so), theSolids);
      (*theFile) << ":SOLID " << AddQuotes(bsoName) << " SCALED "
		 << unscaledSolid->GetName() << " "
		 << scaleTransf.xx() << " "
		 << scaleTransf.yy() << " "
		 << scaleTransf.zz() << G4endl;
    }
}

// --------------------------------------------------------------------
void G4tgbGeometryDumper::DumpSolidParams(G4VSolid* so)
{
  std::vector<G4double> params = GetSolidParams(so);
  for(std::size_t ii = 0; ii < params.size(); ++ii)
  {
    (*theFile) << params[ii] << " ";
  }
  (*theFile) << G4endl;
}

// --------------------------------------------------------------------
std::vector<G4double> G4tgbGeometryDumper::GetSolidParams(const G4VSolid* so)
{
  std::vector<G4double> params;

  G4String solidType = so->GetEntityType();
  solidType          = GetTGSolidType(solidType);

  if(solidType == "BOX")
  {
    const G4Box* sb = dynamic_cast<const G4Box*>(so);
    if(sb != nullptr)
    {
      params.push_back(sb->GetXHalfLength());
      params.push_back(sb->GetYHalfLength());
      params.push_back(sb->GetZHalfLength());
    }
  }
  else if(solidType == "TUBS")
  {
    const G4Tubs* tu = dynamic_cast<const G4Tubs*>(so);
    if(tu != nullptr)
    {
      params.push_back(tu->GetInnerRadius());
      params.push_back(tu->GetOuterRadius());
      params.push_back(tu->GetZHalfLength());
      params.push_back(tu->GetStartPhiAngle() / deg);
      params.push_back(tu->GetDeltaPhiAngle() / deg);
    }
  }
  else if(solidType == "TRAP")
  {
    const G4Trap* trp = dynamic_cast<const G4Trap*>(so);
    if(trp != nullptr)
    {
      G4ThreeVector symAxis(trp->GetSymAxis());
      params.push_back(trp->GetZHalfLength());
      params.push_back(symAxis.theta() / deg);
      params.push_back(symAxis.phi() / deg);
      params.push_back(trp->GetYHalfLength1());
      params.push_back(trp->GetXHalfLength1());
      params.push_back(trp->GetXHalfLength2());
      params.push_back(std::atan(trp->GetTanAlpha1()) / deg);
      params.push_back(trp->GetYHalfLength2());
      params.push_back(trp->GetXHalfLength3());
      params.push_back(trp->GetXHalfLength4());
      params.push_back(std::atan(trp->GetTanAlpha2()) / deg);
    }
  }
  else if(solidType == "TRD")
  {
    const G4Trd* tr = dynamic_cast<const G4Trd*>(so);
    if(tr != nullptr)
    {
      params.push_back(tr->GetXHalfLength1());
      params.push_back(tr->GetXHalfLength2());
      params.push_back(tr->GetYHalfLength1());
      params.push_back(tr->GetYHalfLength2());
      params.push_back(tr->GetZHalfLength());
    }
  }
  else if(solidType == "PARA")
  {
    const G4Para* para = dynamic_cast<const G4Para*>(so);
    if(para != nullptr)
    {
      G4ThreeVector symAxis(para->GetSymAxis());
      params.push_back(para->GetXHalfLength());
      params.push_back(para->GetYHalfLength());
      params.push_back(para->GetZHalfLength());
      params.push_back(std::atan(para->GetTanAlpha()) / deg);
      params.push_back(symAxis.theta() / deg);
      params.push_back(symAxis.phi() / deg);
    }
  }
  else if(solidType == "CONS")
  {
    const G4Cons* cn = dynamic_cast<const G4Cons*>(so);
    if(cn != nullptr)
    {
      params.push_back(cn->GetInnerRadiusMinusZ());
      params.push_back(cn->GetOuterRadiusMinusZ());
      params.push_back(cn->GetInnerRadiusPlusZ());
      params.push_back(cn->GetOuterRadiusPlusZ());
      params.push_back(cn->GetZHalfLength());
      params.push_back(cn->GetStartPhiAngle() / deg);
      params.push_back(cn->GetDeltaPhiAngle() / deg);
    }
  }
  else if(solidType == "SPHERE")
  {
    const G4Sphere* sphere = dynamic_cast<const G4Sphere*>(so);
    if(sphere != nullptr)
    {
      params.push_back(sphere->GetInnerRadius());
      params.push_back(sphere->GetOuterRadius());
      params.push_back(sphere->GetStartPhiAngle() / deg);
      params.push_back(sphere->GetDeltaPhiAngle() / deg);
      params.push_back(sphere->GetStartThetaAngle() / deg);
      params.push_back(sphere->GetDeltaThetaAngle() / deg);
    }
  }
  else if(solidType == "ORB")
  {
    const G4Orb* orb = dynamic_cast<const G4Orb*>(so);
    if(orb != nullptr)
    {
      params.push_back(orb->GetRadius());
    }
  }
  else if(solidType == "TORUS")
  {
    const G4Torus* torus = dynamic_cast<const G4Torus*>(so);
    if(torus != nullptr)
    {
      params.push_back(torus->GetRmin());
      params.push_back(torus->GetRmax());
      params.push_back(torus->GetRtor());
      params.push_back(torus->GetSPhi() / deg);
      params.push_back(torus->GetDPhi() / deg);
    }
  }
  else if(solidType == "POLYCONE")
  {
    //--- Dump RZ corners, as original parameters will not be present
    //    if it was build from RZ corners
    const G4Polycone* plc = dynamic_cast<const G4Polycone*>(so);
    if(plc != nullptr)
    {
      G4double angphi = plc->GetStartPhi() / deg;
      if(angphi > 180 * deg)
      {
        angphi -= 360 * deg;
      }
      G4double endphi = plc->GetEndPhi() / deg;
      if(endphi > 180 * deg)
      {
        endphi -= 360 * deg;
      }
      params.push_back(angphi);
      params.push_back(endphi - angphi);
      //      params.push_back(plc->GetOriginalParameters()->Opening_angle / deg);
      G4int ncor = plc->GetNumRZCorner();
      params.push_back(ncor);

      for(G4int ii = 0; ii < ncor; ++ii)
      {
        params.push_back(plc->GetCorner(ii).r);
        params.push_back(plc->GetCorner(ii).z);
      }
    }
  }
  else if(solidType == "GENERICPOLYCONE")
  {
    //--- Dump RZ corners
    const G4GenericPolycone* plc = dynamic_cast<const G4GenericPolycone*>(so);
    if(plc != nullptr)
    {
      G4double angphi = plc->GetStartPhi() / deg;
      if(angphi > 180 * deg)
      {
        angphi -= 360 * deg;
      }
      G4double endphi = plc->GetEndPhi() / deg;
      if(endphi > 180 * deg)
      {
        endphi -= 360 * deg;
      }
      params.push_back(angphi);
      params.push_back(endphi - angphi);
      G4int ncor = plc->GetNumRZCorner();
      params.push_back(ncor);

      for(G4int ii = 0; ii < ncor; ++ii)
      {
        params.push_back(plc->GetCorner(ii).r);
        params.push_back(plc->GetCorner(ii).z);
      }
    }
  }
  else if(solidType == "POLYHEDRA")
  {
    //--- Dump RZ corners, as original parameters will not be present
    //    if it was build from RZ corners
    const G4Polyhedra* ph = (dynamic_cast<const G4Polyhedra*>(so));
    if(ph != nullptr)
    {
      G4double angphi = ph->GetStartPhi() / deg;
      if(angphi > 180 * deg)
        angphi -= 360 * deg;

      G4int ncor = ph->GetNumRZCorner();

      params.push_back(angphi);
      params.push_back(ph->GetOriginalParameters()->Opening_angle / deg);
      params.push_back(ph->GetNumSide());
      params.push_back(ncor);

      for(G4int ii = 0; ii < ncor; ++ii)
      {
        params.push_back(ph->GetCorner(ii).r);
        params.push_back(ph->GetCorner(ii).z);
      }
    }
  }
  else if(solidType == "ELLIPTICALTUBE")
  {
    const G4EllipticalTube* eltu = dynamic_cast<const G4EllipticalTube*>(so);
    if(eltu != nullptr)
    {
      params.push_back(eltu->GetDx());
      params.push_back(eltu->GetDy());
      params.push_back(eltu->GetDz());
    }
  }
  else if(solidType == "ELLIPSOID")
  {
    const G4Ellipsoid* dso = dynamic_cast<const G4Ellipsoid*>(so);
    if(dso != nullptr)
    {
      params.push_back(dso->GetSemiAxisMax(0));
      params.push_back(dso->GetSemiAxisMax(1));
      params.push_back(dso->GetSemiAxisMax(2));
      params.push_back(dso->GetZBottomCut());
      params.push_back(dso->GetZTopCut());
    }
  }
  else if(solidType == "ELLIPTICAL_CONE")
  {
    const G4EllipticalCone* elco = dynamic_cast<const G4EllipticalCone*>(so);
    if(elco != nullptr)
    {
      params.push_back(elco->GetSemiAxisX());
      params.push_back(elco->GetSemiAxisY());
      params.push_back(elco->GetZMax());
      params.push_back(elco->GetZTopCut());
    }
  }
  else if(solidType == "HYPE")
  {
    const G4Hype* hype = dynamic_cast<const G4Hype*>(so);
    if(hype != nullptr)
    {
      params.push_back(hype->GetInnerRadius());
      params.push_back(hype->GetOuterRadius());
      params.push_back(hype->GetInnerStereo() / deg);
      params.push_back(hype->GetOuterStereo() / deg);
      params.push_back(2 * hype->GetZHalfLength());
    }
    //  } else if( solidType == "TET" ) {
  }
  else if(solidType == "TWISTEDBOX")
  {
    const G4TwistedBox* tbox = dynamic_cast<const G4TwistedBox*>(so);
    if(tbox != nullptr)
    {
      params.push_back(tbox->GetPhiTwist() / deg);
      params.push_back(tbox->GetXHalfLength());
      params.push_back(tbox->GetYHalfLength());
      params.push_back(tbox->GetZHalfLength());
    }
  }
  else if(solidType == "TWISTEDTRAP")
  {
    const G4TwistedTrap* ttrap = dynamic_cast<const G4TwistedTrap*>(so);
    if(ttrap != nullptr)
    {
      params.push_back(ttrap->GetPhiTwist() / deg);
      params.push_back(ttrap->GetZHalfLength());
      params.push_back(ttrap->GetPolarAngleTheta() / deg);
      params.push_back(ttrap->GetAzimuthalAnglePhi() / deg);
      params.push_back(ttrap->GetY1HalfLength());
      params.push_back(ttrap->GetX1HalfLength());
      params.push_back(ttrap->GetX2HalfLength());
      params.push_back(ttrap->GetY2HalfLength());
      params.push_back(ttrap->GetX3HalfLength());
      params.push_back(ttrap->GetX4HalfLength());
      params.push_back(ttrap->GetTiltAngleAlpha() / deg);
    }
  }
  else if(solidType == "TWISTEDTRD")
  {
    const G4TwistedTrd* ttrd = dynamic_cast<const G4TwistedTrd*>(so);
    if(ttrd != nullptr)
    {
      params.push_back(ttrd->GetX1HalfLength());
      params.push_back(ttrd->GetX2HalfLength());
      params.push_back(ttrd->GetY1HalfLength());
      params.push_back(ttrd->GetY2HalfLength());
      params.push_back(ttrd->GetZHalfLength());
      params.push_back(ttrd->GetPhiTwist() / deg);
    }
  }
  else if(solidType == "TWISTEDTUBS")
  {
    const G4TwistedTubs* ttub = dynamic_cast<const G4TwistedTubs*>(so);
    if(ttub != nullptr)
    {
      params.push_back(ttub->GetInnerRadius());
      params.push_back(ttub->GetOuterRadius());
      params.push_back(ttub->GetZHalfLength());
      params.push_back(ttub->GetDPhi() / deg);
      params.push_back(ttub->GetPhiTwist() / deg);
    }
  }
  else
  {
    const G4String& ErrMessage = "Solid type not supported, sorry... " + solidType;
    G4Exception("G4tgbGeometryDumper::DumpSolidParams()", "NotImplemented",
                FatalException, ErrMessage);
  }

  return params;
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::DumpRotationMatrix(G4RotationMatrix* rotm)
{
  if(rotm == nullptr)
  {
    rotm = new G4RotationMatrix();
  }

  G4double de      = MatDeterminant(rotm);
  G4String rotName = LookForExistingRotation(rotm);
  if(rotName != "")
  {
    return rotName;
  }

  G4ThreeVector v(1., 1., 1.);
  if(de < -0.9)  // a reflection ....
  {
    (*theFile) << ":ROTM ";
    rotName = "RRM";
    rotName += G4UIcommand::ConvertToString(theRotationNumber++);

    (*theFile) << AddQuotes(rotName) << std::setprecision(9) << " "
               << approxTo0(rotm->xx()) << " " << approxTo0(rotm->yx()) << " "
               << approxTo0(rotm->zx()) << " " << approxTo0(rotm->xy()) << " "
               << approxTo0(rotm->yy()) << " " << approxTo0(rotm->zy()) << " "
               << approxTo0(rotm->xz()) << " " << approxTo0(rotm->yz()) << " "
               << approxTo0(rotm->zz()) << G4endl;
  }
  else if(de > 0.9)  // a rotation ....
  {
    (*theFile) << ":ROTM ";
    rotName = "RM";
    rotName += G4UIcommand::ConvertToString(theRotationNumber++);

    (*theFile) << AddQuotes(rotName) << " " << approxTo0(rotm->thetaX() / deg)
               << " " << approxTo0(rotm->phiX() / deg) << " "
               << approxTo0(rotm->thetaY() / deg) << " "
               << approxTo0(rotm->phiY() / deg) << " "
               << approxTo0(rotm->thetaZ() / deg) << " "
               << approxTo0(rotm->phiZ() / deg) << G4endl;
  }

  theRotMats[rotName] = rotm;

  return rotName;
}

// --------------------------------------------------------------------
std::vector<G4VPhysicalVolume*>
G4tgbGeometryDumper::GetPVChildren(G4LogicalVolume* lv)
{
  G4PhysicalVolumeStore* pvstore = G4PhysicalVolumeStore::GetInstance();
  std::vector<G4VPhysicalVolume*> children;
  for(auto ite = pvstore->cbegin(); ite != pvstore->cend(); ++ite)
  {
    if((*ite)->GetMotherLogical() == lv)
    {
      children.push_back(*ite);
#ifdef G4VERBOSE
      if(G4tgrMessenger::GetVerboseLevel() >= 1)
      {
        G4cout << " G4tgbGeometryDumper::GetPVChildren() - adding children: "
               << (*ite)->GetName() << " of " << lv->GetName() << G4endl;
      }
#endif
    }
  }

  return children;
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::GetTGSolidType(const G4String& solidType)
{
  G4String newsolidType = solidType.substr(2, solidType.length());
  for(G4int ii = 0; ii < (G4int)newsolidType.length(); ++ii)
  {
    newsolidType[ii] = (char)std::toupper(newsolidType[ii]);
  }
  return newsolidType;
}

// --------------------------------------------------------------------
G4double G4tgbGeometryDumper::MatDeterminant(G4RotationMatrix* ro)
{
  G4Rep3x3 r = ro->rep3x3();
  return r.xx_ * (r.yy_ * r.zz_ - r.zy_ * r.yz_) -
         r.yx_ * (r.xy_ * r.zz_ - r.zy_ * r.xz_) +
         r.zx_ * (r.xy_ * r.yz_ - r.yy_ * r.xz_);
}

// --------------------------------------------------------------------
G4double G4tgbGeometryDumper::approxTo0(G4double val)
{
  G4double precision =
    G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();

  if(std::fabs(val) < precision)
  {
    val = 0.0;
  }
  return val;
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::AddQuotes(const G4String& str)
{
  //--- look if there is a separating blank

  G4bool bBlank = FALSE;
  std::size_t siz = str.length();
  for(std::size_t ii = 0; ii < siz; ++ii)
  {
    if(str.substr(ii, 1) == " ")
    {
      bBlank = TRUE;
      break;
    }
  }
  G4String str2 = str;
  if(bBlank)
  {
    str2 = G4String("\"") + str2 + G4String("\"");
  }
  return str2;
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::SupressRefl(G4String name)
{
  std::size_t irefl = name.rfind("_refl");
  if(irefl != G4String::npos)
  {
    name = name.substr(0, irefl);
  }
  return name;
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::SubstituteRefl(G4String name)
{
  std::size_t irefl = name.rfind("_refl");
  if(irefl != G4String::npos)
  {
    name = name.substr(0, irefl) + "_REFL";
  }
  return name;
}

// --------------------------------------------------------------------
G4String G4tgbGeometryDumper::GetIsotopeName(G4Isotope* isot)
{
  G4String isotName = isot->GetName();
  // first look if this is isotope is already dumped,
  // with original isotope name or new one
  //
  std::map<G4String, G4Isotope*>::const_iterator ite;
  for(ite = theIsotopes.cbegin(); ite != theIsotopes.cend(); ++ite)
  {
    if(isot == (*ite).second)
    {
      return (*ite).first;
    }
  }

  // Now look if there is another isotope dumped with same name,
  // and if found add _N to the name
  //
  ite = theIsotopes.find(isotName);
  if(ite != theIsotopes.cend())  // Isotope found with same name
  {
    G4Isotope* isotold = (*ite).second;
    if(isot != isotold)  // new isotope it is not the really
    {                    // the same one as isotope found
      if(!Same2G4Isotopes(isot, isotold))
      {                // if the two have same data, use the old one
        G4int ii = 2;  // G4Nist does names isotopes of same element
                       // with same name
        for(;; ++ii)
        {
          const G4String& newIsotName =
            isotName + "_" + G4UIcommand::ConvertToString(ii);
          std::map<G4String, G4Isotope*>::const_iterator ite2 =
            theIsotopes.find(newIsotName);
          if(ite2 == theIsotopes.cend())
          {
            isotName = newIsotName;
            break;
          }
          else
          {
            if(Same2G4Isotopes(isot, (*ite2).second))
            {
              isotName = newIsotName;
              break;
            }
          }
        }
      }
    }
  }
  return isotName;
}

// --------------------------------------------------------------------
template <class TYP>
G4String G4tgbGeometryDumper::GetObjectName(
  TYP* obj, std::map<G4String, TYP*> objectsDumped)
{
  G4String objName = obj->GetName();

  // first look if this is objecy is already dumped,
  // with original object name or new one
  //
  typename std::map<G4String, TYP*>::const_iterator ite;
  for(ite = objectsDumped.cbegin(); ite != objectsDumped.cend(); ++ite)
  {
    if(obj == (*ite).second)
    {
      return (*ite).first;
    }
  }

  // Now look if there is another object dumped with same name,
  // and if found add _N to the name
  //
  ite = objectsDumped.find(objName);

  if(ite != objectsDumped.cend())  // Object found with same name
  {
    TYP* objold = (*ite).second;
    if(obj != objold)  // new object it is not the really
    {                  // the same one as object found
      G4int ii = 2;
      for(;; ++ii)
      {
        const G4String& newObjName = objName + "_" + G4UIcommand::ConvertToString(ii);
        typename std::map<G4String, TYP*>::const_iterator ite2 =
          objectsDumped.find(newObjName);
        if(ite2 == objectsDumped.cend())
        {
          objName = newObjName;
          break;
        }
      }
    }
  }
  return objName;
}

// --------------------------------------------------------------------
G4bool G4tgbGeometryDumper::CheckIfLogVolExists(const G4String& name,
                                                G4LogicalVolume* pt)
{
  if(theLogVols.find(name) != theLogVols.cend())
  {
    G4LogicalVolume* lvnew = (*(theLogVols.find(name))).second;
    if(lvnew != pt)
    {
      /*
      //---- Reflected volumes are repeated

      G4ReflectionFactory* reffact = G4ReflectionFactory::Instance();
      if( !reffact->IsReflected( pt ) && !reffact->IsReflected( lvnew ) )
      {
        G4String ErrMessage = "LogVol found but not same as before: " + name;
        G4Exception("G4tgbGeometryDumper::CheckIfLogVolExists()",
                    "InvalidSetup", FatalException, ErrMessage);
      }
      */
    }
    return true;
  }
  else
  {
    return false;
  }
}

// --------------------------------------------------------------------
G4bool G4tgbGeometryDumper::CheckIfPhysVolExists(const G4String& name,
                                                 G4VPhysicalVolume* pt)
{
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 1)
  {
    G4cout << " G4tgbGeometryDumper::CheckIfPhysVolExists() - " << name
           << G4endl;
  }
#endif
  if(thePhysVols.find(name) != thePhysVols.cend())
  {
    if((*(thePhysVols.find(name))).second != pt)
    {
      // G4String ErrMessage = "Placement found but not same as before: "
      //                     + name;
      // G4Exception("G4tgbGeometryDumper::CheckIfPhysVolExists()",
      //             "InvalidSetup", FatalException, ErrMessage);
      G4cerr << " G4tgbGeometryDumper::CheckIfPhysVolExists () -"
             << " Placement found but not same as before : " << name << G4endl;
    }
    return true;
  }
  else
  {
    return false;
  }
}

// --------------------------------------------------------------------
G4String
G4tgbGeometryDumper::LookForExistingRotation(const G4RotationMatrix* rotm)
{
  G4String rmName = "";

  for(auto ite = theRotMats.cbegin(); ite != theRotMats.cend(); ++ite)
  {
    if((*ite).second->isNear(*rotm))
    {
      rmName = (*ite).first;
      break;
    }
  }
  return rmName;
}

// --------------------------------------------------------------------
G4bool G4tgbGeometryDumper::Same2G4Isotopes(G4Isotope* isot1, G4Isotope* isot2)
{
  if((isot1->GetZ() != isot2->GetZ()) || (isot1->GetN() != isot2->GetN()) ||
     (isot1->GetA() != isot2->GetA()))
  {
    return false;
  }
  else
  {
    return true;
  }
}

// --------------------------------------------------------------------
const G4String& G4tgbGeometryDumper::FindSolidName(G4VSolid* solid)
{
  std::map<G4String, G4VSolid*>::const_iterator ite;
  for(ite = theSolids.cbegin(); ite != theSolids.cend(); ++ite)
  {
    if(solid == (*ite).second)
    {
      return (*ite).first;
    }
  }

  if(ite == theSolids.cend())
  {
    G4Exception("G4tgbGeometryDumper::FindSolidName()", "ReadError",
                FatalException, "Programming error.");
  }
  return (*ite).first;
}