working on Name LUT (37cb94d5) · Commits · Alvarez, Gonzalo / merapp

src/Engine/MeraSolver.h

+45 −51

Original line number	Diff line number	Diff line
		@@ -53,6 +53,8 @@ class MeraSolver {
		typedef ModelSelector<ModelBaseType> ModelType;
		typedef typename TensorOptimizerType::SymmetryLocalType SymmetryLocalType;
		typedef typename TensorOptimizerType::ParametersForMeraType ParametersForMeraType;
		typedef TensorEvalSlow<ComplexOrRealType> TensorEvalSlowType;
		typedef TensorEvalNew<ComplexOrRealType> TensorEvalNewType;

		static const int EVAL_BREAKUP = TensorOptimizerType::EVAL_BREAKUP;

		@@ -66,6 +68,7 @@ public:
		iterMera_(1),
		iterTensor_(1),
		indexOfRootTensor_(0),
		nameToIndexLut_(0),
		model_(paramsForMera_.model, paramsForMera_.hamiltonianConnection),
		paramsForLanczos_(0)
		{
		@@ -107,6 +110,7 @@ public:

		updateTensorSizes(noSymmLocal);

		nameToIndexLut_ = new NameToIndexLut<TensorType>(tensors_);
		bool rootTensorFound = false;
		while (true) {
		PsimagLite::String str("");
		@@ -154,9 +158,8 @@ public:
		tensorOptimizer_.push_back(new TensorOptimizerType(io,
		name,
		id,
		tensorNameIds_,
		nameIdsTensor_,
		tensors_,
		*nameToIndexLut_,
		*paramsForLanczos_,
		paramsForMera_,
		symmLocal_));
		@@ -269,15 +272,13 @@ private:

		ParallelEnergyHelper(SymmetryLocalType* symmLocal,
		VectorSrepStatementType& energyTerms,
		const VectorPairStringSizeType& tensorNameAndIds,
		MapPairStringSizeType& nameIdsTensor,
		VectorTensorType& tensors,
		NameToIndexLut<TensorType>& nameToIndexLut,
		const ParametersForMeraType& paramsForMera)
		: symmLocal_(symmLocal),
		energyTerms_(energyTerms),
		tensorNameIds_(tensorNameAndIds),
		nameIdsTensor_(nameIdsTensor),
		tensors_(tensors),
		nameToIndexLut_(nameToIndexLut),
		paramsForMera_(paramsForMera),
		e_(PsimagLite::Concurrency::codeSectionParams.npthreads, 0.0)
		{}
		@@ -311,27 +312,28 @@ private:
		assert(ind < energyTerms_.size());
		SrepStatementType* ptr = energyTerms_[ind];
		if (!ptr) return 0.0;
		TensorEvalBaseType* tensorEval =
		TensorOptimizerType::getTensorEvalPtr(paramsForMera_.evaluator,
		TensorEvalBaseType* tensorEval = TensorOptimizerType::ParallelEnvironHelperType::
		getTensorEvalPtr(paramsForMera_.evaluator,
		*ptr,
		tensors_,
		tensorNameIds_,
		nameIdsTensor_,
		nameToIndexLut_,
		symmLocal_);

		typename TensorEvalBaseType::HandleType handle = tensorEval->operator()();
		while (!handle.done());

		VectorSizeType args(1,0);
		const SizeType index = tensorEval->nameToIndexLut("e" + ttos(ind));
		delete tensorEval;
		tensorEval = 0;
		VectorSizeType args(1,0);
		return tensors_[nameIdsTensor_[PairStringSizeType("e",ind)]]->operator()(args);
		assert(index < tensors_.size());
		return tensors_[index]->operator()(args);
		}

		SymmetryLocalType* symmLocal_;
		VectorSrepStatementType& energyTerms_;
		const VectorPairStringSizeType& tensorNameIds_;
		MapPairStringSizeType& nameIdsTensor_;
		VectorTensorType& tensors_;
		NameToIndexLut<TensorType>& nameToIndexLut_;
		const ParametersForMeraType& paramsForMera_;
		VectorRealType e_;
		}; // class ParallelEnergyHelper
		@@ -343,9 +345,8 @@ private:

		ParallelEnergyHelper parallelEnergyHelper(symmLocal_,
		energyTerms_,
		tensorNameIds_,
		nameIdsTensor_,
		tensors_,
		*nameToIndexLut_,
		paramsForMera_);

		threadedEnergies.loopCreate(parallelEnergyHelper);
		@@ -353,22 +354,20 @@ private:
		return parallelEnergyHelper.energy();
		}

		void initTensorNameIds()
		void initTensorNameIds(VectorPairStringSizeType& tensorNameIds)
		{
		PsimagLite::Sort<VectorPairStringSizeType> sort;
		VectorSizeType perm(tensorNameIds_.size(),0);
		sort.sort(tensorNameIds_,perm);
		SizeType end = (std::unique(tensorNameIds_.begin(),
		tensorNameIds_.end()) -
		tensorNameIds_.begin());
		tensorNameIds_.resize(end);
		for (SizeType i = 0; i < tensorNameIds_.size(); ++i)
		nameIdsTensor_[tensorNameIds_[i]] = i;
		VectorSizeType perm(tensorNameIds.size(),0);
		sort.sort(tensorNameIds,perm);
		SizeType end = (std::unique(tensorNameIds.begin(),
		tensorNameIds.end()) - tensorNameIds.begin());
		tensorNameIds.resize(end);
		}

		void initTensors(const TensorSrep& td)
		void initTensors(const VectorPairStringSizeType& tensorNameIds,
		const TensorSrep& td)
		{
		tensors_.resize(tensorNameIds_.size());
		tensors_.resize(tensorNameIds.size());
		SizeType ntensors = tensors_.size();

		if (td.size() != ntensors) {
		@@ -381,15 +380,15 @@ private:
		PsimagLite::String name = td(i).name();
		SizeType id = td(i).id();
		PairStringSizeType p(name, id);
		typename VectorPairStringSizeType::iterator x = std::find(tensorNameIds_.begin(),
		tensorNameIds_.end(),
		typename VectorPairStringSizeType::const_iterator x = std::find(tensorNameIds.begin(),
		tensorNameIds.end(),
		p);
		if (x == tensorNameIds_.end()) {
		if (x == tensorNameIds.end()) {
		std::cerr<<"WARNING: Unused tensor name= "<<name<<" id= "<<id<<"\n";
		continue;
		}

		SizeType ind = x - tensorNameIds_.begin();
		SizeType ind = x - tensorNameIds.begin();
		assert(ind < tensors_.size());

		SizeType legs = td(i).legs();
		@@ -401,7 +400,7 @@ private:

		SizeType ins = td(i).ins();
		assert(ind < tensors_.size());
		tensors_[ind] = new TensorType(dimensions,ins);
		tensors_[ind] = new TensorType(name + ttos(id), dimensions, ins);
		if (name == "h") {
		tensors_[ind]->setToMatrix(model_().twoSiteHam(id));
		} else {
		@@ -410,14 +409,15 @@ private:
		}
		}

		void findTensors(const TensorSrep& t)
		void findTensors(VectorPairStringSizeType& tensorNameIds,
		const TensorSrep& t)
		{
		SizeType ntensors = t.size();
		for (SizeType i = 0; i < ntensors; ++i) {
		PsimagLite::String name = t(i).name();
		SizeType id = t(i).id();
		PairStringSizeType p(name,id);
		tensorNameIds_.push_back(p);
		tensorNameIds.push_back(p);
		}
		}

		@@ -427,11 +427,7 @@ private:
		for (SizeType i = 0; i < ntensors; ++i) {
		PsimagLite::String name = srep(i).name();
		SizeType id = srep(i).id();
		PairStringSizeType p(name,id);
		SizeType x = nameIdsTensor_[p];
		if (tensorNameIds_[x] == p) continue;
		PsimagLite::String msg("Not found tensor "+ name + ttos(id) + "\n");
		throw PsimagLite::RuntimeError("allTensorsDefinedOrDie: " + msg);
		nameToIndexLut_->operator()(name + ttos(id));
		}
		}

		@@ -449,12 +445,11 @@ private:
		symmLocal_ = symmLocal;

		TensorSrep tdstr(dsrep);
		if (tensorNameIds_.size() == 0) {
		findTensors(tdstr);
		initTensorNameIds();
		}
		VectorPairStringSizeType tensorNameIds;
		findTensors(tensorNameIds, tdstr);
		initTensorNameIds(tensorNameIds);

		initTensors(tdstr);
		initTensors(tensorNameIds, tdstr);
		}

		MeraSolver(const MeraSolver&);
		@@ -469,9 +464,8 @@ private:
		SizeType iterMera_;
		SizeType iterTensor_;
		SizeType indexOfRootTensor_;
		VectorPairStringSizeType tensorNameIds_;
		MapPairStringSizeType nameIdsTensor_;
		VectorTensorType tensors_;
		NameToIndexLut<TensorType>* nameToIndexLut_;
		ModelType model_;
		VectorTensorOptimizerType tensorOptimizer_;
		ParametersForSolverType* paramsForLanczos_;

src/Engine/ParallelEnvironHelper.h

+28 −43

Original line number	Diff line number	Diff line
		@@ -52,16 +52,14 @@ public:
		ParallelEnvironHelper(VectorSrepStatementType& tensorSrep,
		PsimagLite::String evaluator,
		SizeType ignore,
		const VectorPairStringSizeType& tensorNameAndIds,
		MapPairStringSizeType& nameIdsTensor,
		VectorTensorType& tensors,
		NameToIndexLut<TensorType>& nameToIndexLut,
		SymmetryLocalType* symmLocal)
		: tensorSrep_(tensorSrep),
		evaluator_(evaluator),
		ignore_(ignore),
		tensorNameIds_(tensorNameAndIds),
		nameIdsTensor_(nameIdsTensor),
		tensors_(tensors),
		nameToIndexLut_(nameToIndexLut),
		symmLocal_(symmLocal),
		m_(PsimagLite::Concurrency::codeSectionParams.npthreads, 0)
		{
		@@ -100,32 +98,6 @@ public:
		checkAndAccumulate(*(m_[i]));
		}

		static TensorEvalBaseType* getTensorEvalPtr(PsimagLite::String evaluator,
		const SrepStatementType& srep,
		VectorTensorType& tensors,
		const VectorPairStringSizeType& tensorNameIds,
		MapPairStringSizeType& nameIdsTensor,
		SymmetryLocalType* symmLocal)
		{
		TensorEvalBaseType* tensorEval = 0;
		if (evaluator == "slow") {
		tensorEval = new TensorEvalSlowType(srep,
		tensors,
		tensorNameIds,
		nameIdsTensor,
		symmLocal);
		} else if (evaluator == "new") {
		tensorEval = new TensorEvalNewType(srep,
		tensors,
		tensorNameIds,
		nameIdsTensor);
		} else {
		throw PsimagLite::RuntimeError("Unknown evaluator " + evaluator + "\n");
		}

		return tensorEval;
		}

		void appendToMatrix(MatrixType& m,
		SrepStatementType& eq,
		PsimagLite::String evaluator)
		@@ -155,8 +127,7 @@ public:
		TensorEvalBaseType* tensorEval = getTensorEvalPtr(evaluator,
		eq,
		tensors_,
		tensorNameIds_,
		nameIdsTensor_,
		nameToIndexLut_,
		symmLocal_);

		typename TensorEvalBaseType::HandleType handle = tensorEval->operator()();
		@@ -175,6 +146,24 @@ public:
		} while (ProgramGlobals::nextIndex(freeIndices,dimensions,total));
		}

		static TensorEvalBaseType* getTensorEvalPtr(PsimagLite::String evaluator,
		const SrepStatementType& srep,
		VectorTensorType& tensors,
		NameToIndexLut<TensorType>& nameToIndexLut,
		SymmetryLocalType* symmLocal)
		{
		TensorEvalBaseType* tensorEval = 0;
		if (evaluator == "slow") {
		tensorEval = new TensorEvalSlowType(srep, tensors, nameToIndexLut, symmLocal);
		} else if (evaluator == "new") {
		tensorEval = new TensorEvalNewType(srep, tensors);
		} else {
		throw PsimagLite::RuntimeError("Unknown evaluator " + evaluator + "\n");
		}

		return tensorEval;
		}

		private:

		void prepareFreeIndices(VectorDirType& directions,
		@@ -189,9 +178,8 @@ private:
		for (SizeType i = 0; i < ntensors; ++i) {
		PsimagLite::String name = t(i).name();
		SizeType id = t(i).id();
		PairStringSizeType p(name,id);

		SizeType ind = nameIdsTensor_[p];
		SizeType ind = nameToIndexLut_(name + ttos(id));
		assert(ind < tensors_.size());

		SizeType ins = t(i).ins();
		@@ -278,9 +266,7 @@ private:

		TensorType& outputTensor(const SrepStatementType& eq)
		{
		SizeType indexOfOutputTensor = TensorEvalBaseType::indexOfOutputTensor(eq,
		tensorNameIds_,
		nameIdsTensor_);
		SizeType indexOfOutputTensor = nameToIndexLut_(eq.nameIdOfOutput());
		assert(indexOfOutputTensor < tensors_.size());
		return *(tensors_[indexOfOutputTensor]);
		}
		@@ -303,9 +289,8 @@ private:
		VectorSrepStatementType& tensorSrep_;
		PsimagLite::String evaluator_;
		SizeType ignore_;
		const VectorPairStringSizeType& tensorNameIds_;
		MapPairStringSizeType& nameIdsTensor_;
		VectorTensorType& tensors_;
		NameToIndexLut<TensorType>& nameToIndexLut_;
		SymmetryLocalType* symmLocal_;
		VectorMatrixType m_;
		}; // class ParallelEnvironHelper

src/Engine/Tensor.h

+15 −0

Original line number	Diff line number	Diff line
		@@ -36,6 +36,7 @@ public:
		typedef PsimagLite::Matrix<ComplexOrRealType> MatrixType;
		typedef PsimagLite::Vector<SizeType>::Type VectorSizeType;
		typedef typename PsimagLite::Vector<ComplexOrRealType>::Type VectorComplexOrRealType;
		typedef std::pair<PsimagLite::String, SizeType> PairStringSizeType;

		// Tensor with only one dimension
		Tensor(PsimagLite::String name, SizeType dim0, SizeType ins)
		@@ -252,6 +253,20 @@ public:

		PsimagLite::String name() const { return name_; }

		// static SizeType idNameToIndex(const typename PsimagLite::Vector<Tensor*>::Type& data,
		// const PairStringSizeType& p)
		// {
		// return idNameToIndex(data, p.first + ttos(p.second));

		// }
		// static SizeType idNameToIndex(const typename PsimagLite::Vector<Tensor*>::Type& data,
		// PsimagLite::String nameAndId)
		// {
		// for (SizeType i = 0; i < data.size(); ++i)
		// if (nameAndId == data[i]->name()) return i;

		// throw PsimagLite::RuntimeError("idNameToIndex: key not found\n");
		// }
		private:

src/Engine/TensorEvalBase.h

+1 −12

Original line number	Diff line number	Diff line
		@@ -43,18 +43,7 @@ public:

		virtual void printResult(std::ostream& os) const = 0;

		// static SizeType indexOfOutputTensor(const SrepStatementType& eq)
		// {
		// SizeType ret = nameIdsTensor[eq.nameIdOfOutput()];
		// if (tensorNameIds[ret] != eq.nameIdOfOutput()) {
		// PsimagLite::String msg("TensorEvalBase: Could not find ");
		// msg += "output tensor " + eq.nameIdOfOutput().first;
		// msg += ttos(eq.nameIdOfOutput().second) + "\n";
		// throw PsimagLite::RuntimeError(msg);
		// }

		// return ret;
		// }
		virtual SizeType nameToIndexLut(PsimagLite::String) = 0;
		};
		} // namespace Mera
		#endif // TENSOREVALBASE_H

src/Engine/TensorEvalNew.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,11 @@ public:
		const VectorTensorType& vt)
		{}

		SizeType nameToIndexLut(PsimagLite::String name)
		{
		throw PsimagLite::RuntimeError("Not implemented yet\n");
		}

		HandleType operator()()
		{
		throw PsimagLite::RuntimeError("Not implemented yet\n");